def __init__(self, input_num, num1, num2, dilation_rate, drop_out,
bn_type):
super(_DenseAsppBlock, self).__init__()
self.add_module('relu1', nn.ReLU(inplace=False)),
self.add_module(
'conv1',
nn.Conv2d(in_channels=input_num, out_channels=num1,
kernel_size=1)),
self.add_module(
'norm2',
ModuleHelper.BatchNorm2d(bn_type=bn_type)(num_features=num1)),
self.add_module('relu2', nn.ReLU(inplace=False)),
self.add_module(
'conv2',
nn.Conv2d(in_channels=num1,
out_channels=num2,
kernel_size=3,
dilation=dilation_rate,
padding=dilation_rate)),
self.add_module(
'norm2',
ModuleHelper.BatchNorm2d(bn_type=bn_type)(num_features=input_num)),
self.drop_rate = drop_out
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
bn_type=None,
bn_momentum=0.1):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(
planes, momentum=bn_momentum)
self.conv2 = nn.Conv2d(planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(
planes, momentum=bn_momentum)
self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
self.bn3 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(
planes * 4, momentum=bn_momentum)
self.relu = nn.ReLU(inplace=False)
self.relu_in = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
groups=1,
base_width=64,
dilation=1,
bn_type=None):
super(BasicBlock, self).__init__()
if groups != 1 or base_width != 64:
raise ValueError(
'BasicBlock only supports groups=1 and base_width=64')
if dilation > 1:
raise NotImplementedError(
"Dilation > 1 not supported in BasicBlock")
# Both self.conv1 and self.downsample layers downsample the input when stride != 1
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes)
self.relu = nn.ReLU(inplace=False)
self.relu_in = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes)
self.downsample = downsample
self.stride = stride
def __init__(self, num_class=150, fc_dim=4096, bn_type=None):
super(PPMBilinearDeepsup, self).__init__()
self.bn_type = bn_type
pool_scales = (1, 2, 3, 6)
self.ppm = []
# assert bn_type == 'syncbn' or not self.training
# Torch BN can't handle feature map size with 1x1.
for scale in pool_scales:
self.ppm.append(nn.Sequential(
nn.AdaptiveAvgPool2d(scale),
nn.Conv2d(fc_dim, 512, kernel_size=1, bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(512),
nn.ReLU(inplace=True)
))
self.ppm = nn.ModuleList(self.ppm)
self.cbr_deepsup = _ConvBatchNormReluBlock(fc_dim // 2, fc_dim // 4, 3, 1, bn_type=bn_type)
self.conv_last = nn.Sequential(
nn.Conv2d(fc_dim+len(pool_scales)*512, 512,
kernel_size=3, padding=1, bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(512),
nn.ReLU(inplace=True),
nn.Dropout2d(0.1),
nn.Conv2d(512, num_class, kernel_size=1)
)
self.conv_last_deepsup = nn.Conv2d(fc_dim // 4, num_class, 1, 1, 0)
self.dropout_deepsup = nn.Dropout2d(0.1)
def __init__(self,
in_channels,
channels,
kernel_size,
stride=(1, 1),
padding=(0, 0),
dilation=(1, 1),
groups=1,
bias=True,
radix=2,
reduction_factor=4,
rectify=False,
rectify_avg=False,
bn_type=None,
dropblock_prob=0.0,
**kwargs):
super(SplAtConv2d, self).__init__()
padding = _pair(padding)
self.rectify = rectify and (padding[0] > 0 or padding[1] > 0)
self.rectify_avg = rectify_avg
inter_channels = max(in_channels * radix // reduction_factor, 32)
self.radix = radix
self.cardinality = groups
self.channels = channels
self.dropblock_prob = dropblock_prob
if self.rectify:
from rfconv import RFConv2d
self.conv = RFConv2d(in_channels,
channels * radix,
kernel_size,
stride,
padding,
dilation,
groups=groups * radix,
bias=bias,
average_mode=rectify_avg,
**kwargs)
else:
self.conv = Conv2d(in_channels,
channels * radix,
kernel_size,
stride,
padding,
dilation,
groups=groups * radix,
bias=bias,
**kwargs)
self.use_bn = bn_type is not None
self.bn0 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(channels * radix)
self.relu = ReLU(inplace=False)
self.fc1 = Conv2d(channels, inter_channels, 1, groups=self.cardinality)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(inter_channels)
self.fc2 = Conv2d(inter_channels,
channels * radix,
1,
groups=self.cardinality)
if dropblock_prob > 0.0:
self.dropblock = DropBlock2D(dropblock_prob, 3)
self.rsoftmax = rSoftMax(radix, groups)
def _make_fuse_layers(self, bn_type, bn_momentum=0.1):
if self.num_branches == 1:
return None
num_branches = self.num_branches
num_inchannels = self.num_inchannels
fuse_layers = []
for i in range(num_branches if self.multi_scale_output else 1):
fuse_layer = []
for j in range(num_branches):
if j > i:
fuse_layer.append(
nn.Sequential(
nn.Conv2d(num_inchannels[j],
num_inchannels[i],
1,
1,
0,
bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(
num_inchannels[i], momentum=bn_momentum),
))
elif j == i:
fuse_layer.append(None)
else:
conv3x3s = []
for k in range(i - j):
if k == i - j - 1:
num_outchannels_conv3x3 = num_inchannels[i]
conv3x3s.append(
nn.Sequential(
nn.Conv2d(num_inchannels[j],
num_outchannels_conv3x3,
3,
2,
1,
bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(
num_outchannels_conv3x3,
momentum=bn_momentum)))
else:
num_outchannels_conv3x3 = num_inchannels[j]
conv3x3s.append(
nn.Sequential(
nn.Conv2d(num_inchannels[j],
num_outchannels_conv3x3,
3,
2,
1,
bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(
num_outchannels_conv3x3,
momentum=bn_momentum),
nn.ReLU(inplace=False)))
fuse_layer.append(nn.Sequential(*conv3x3s))
fuse_layers.append(nn.ModuleList(fuse_layer))
return nn.ModuleList(fuse_layers)
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
norm_type=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = ModuleHelper.BatchNorm2d(norm_type=norm_type)(planes)
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = ModuleHelper.BatchNorm2d(norm_type=norm_type)(planes)
self.downsample = downsample
self.stride = stride
def _make_head(self, pre_stage_channels, bn_type, bn_momentum):
head_block = Bottleneck
head_channels = [32, 64, 128, 256]
Log.info("pre_stage_channels: {}".format(pre_stage_channels))
Log.info("head_channels: {}".format(head_channels))
# Increasing the #channels on each resolution
# from C, 2C, 4C, 8C to 128, 256, 512, 1024
incre_modules = []
for i, channels in enumerate(pre_stage_channels):
incre_module = self._make_layer(head_block,
channels,
head_channels[i],
1,
bn_type=bn_type,
bn_momentum=bn_momentum)
incre_modules.append(incre_module)
incre_modules = nn.ModuleList(incre_modules)
# downsampling modules
downsamp_modules = []
for i in range(len(pre_stage_channels) - 1):
in_channels = head_channels[i] * head_block.expansion
out_channels = head_channels[i + 1] * head_block.expansion
downsamp_module = nn.Sequential(
nn.Conv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=3,
stride=2,
padding=1),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(
out_channels, momentum=bn_momentum),
nn.ReLU(inplace=False))
downsamp_modules.append(downsamp_module)
downsamp_modules = nn.ModuleList(downsamp_modules)
final_layer = nn.Sequential(
nn.Conv2d(in_channels=head_channels[3] * head_block.expansion,
out_channels=2048,
kernel_size=1,
stride=1,
padding=0),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(2048,
momentum=bn_momentum),
nn.ReLU(inplace=False))
return incre_modules, downsamp_modules, final_layer
def _make_layer(self,
block,
planes,
blocks,
stride=1,
norm_type=None,
rm_last_stride=False):
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
if rm_last_stride:
stride = 1
downsample = nn.Sequential(
nn.Conv2d(self.inplanes,
planes * block.expansion,
kernel_size=1,
stride=stride,
bias=False),
ModuleHelper.BatchNorm2d(norm_type=norm_type)(planes *
block.expansion),
)
layers = []
layers.append(
block(self.inplanes,
planes,
stride,
downsample,
norm_type=norm_type))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(block(self.inplanes, planes, norm_type=norm_type))
return nn.Sequential(*layers)
def __init__(self, inplanes, outplanes, kernel_size, stride, padding=1, dilation=1, relu=True, bn_type=None):
super(_ConvBatchNormReluBlock, self).__init__()
self.relu = relu
self.conv = nn.Conv2d(in_channels=inplanes,out_channels=outplanes,
kernel_size=kernel_size, stride=stride, padding=padding,
dilation = dilation, bias=False)
self.bn = ModuleHelper.BatchNorm2d(bn_type=bn_type)(num_features=outplanes)
self.relu_f = nn.ReLU()
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
bn_type=None,
bn_momentum=0.1):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(
planes, momentum=bn_momentum)
self.relu = nn.ReLU(inplace=False)
self.relu_in = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(
planes, momentum=bn_momentum)
self.downsample = downsample
self.stride = stride
def _make_transition_layer(self, num_channels_pre_layer,
num_channels_cur_layer, bn_type, bn_momentum):
num_branches_cur = len(num_channels_cur_layer)
num_branches_pre = len(num_channels_pre_layer)
transition_layers = []
for i in range(num_branches_cur):
if i < num_branches_pre:
if num_channels_cur_layer[i] != num_channels_pre_layer[i]:
transition_layers.append(
nn.Sequential(
nn.Conv2d(num_channels_pre_layer[i],
num_channels_cur_layer[i],
3,
1,
1,
bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(
num_channels_cur_layer[i],
momentum=bn_momentum), nn.ReLU(inplace=False)))
else:
transition_layers.append(None)
else:
conv3x3s = []
for j in range(i + 1 - num_branches_pre):
inchannels = num_channels_pre_layer[-1]
outchannels = num_channels_cur_layer[i] \
if j == i-num_branches_pre else inchannels
conv3x3s.append(
nn.Sequential(
nn.Conv2d(inchannels,
outchannels,
3,
2,
1,
bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(
outchannels, momentum=bn_momentum),
nn.ReLU(inplace=False)))
transition_layers.append(nn.Sequential(*conv3x3s))
return nn.ModuleList(transition_layers)
def make_res_layer(block,
inplanes,
planes,
blocks,
stride=1,
dilation=1,
style='pytorch',
with_cp=False,
with_dcn=False,
dcn_offset_lr_mult=0.1,
use_regular_conv_on_stride=False,
use_modulated_dcn=False,
bn_type=None):
downsample = None
if stride != 1 or inplanes != planes * block.expansion:
downsample = nn.Sequential(
nn.Conv2d(inplanes,
planes * block.expansion,
kernel_size=1,
stride=stride,
bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes *
block.expansion),
)
layers = []
layers.append(
block(inplanes,
planes,
stride,
dilation,
downsample,
style=style,
with_cp=with_cp,
with_dcn=with_dcn,
dcn_offset_lr_mult=dcn_offset_lr_mult,
use_regular_conv_on_stride=use_regular_conv_on_stride,
use_modulated_dcn=use_modulated_dcn,
bn_type=bn_type))
inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(
block(inplanes,
planes,
1,
dilation,
style=style,
with_cp=with_cp,
with_dcn=with_dcn,
dcn_offset_lr_mult=dcn_offset_lr_mult,
use_regular_conv_on_stride=use_regular_conv_on_stride,
use_modulated_dcn=use_modulated_dcn,
bn_type=bn_type))
return nn.Sequential(*layers)
def __init__(self,
inplanes,
planes,
stride=1,
dilation=1,
downsample=None,
style='pytorch',
with_cp=False,
bn_type=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride, dilation)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes)
self.relu = nn.ReLU(inplace=False)
self.relu_in = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes)
self.downsample = downsample
self.stride = stride
self.dilation = dilation
assert not with_cp
def __init__(self, num_input_features, num_output_features, bn_type):
super(_Transition, self).__init__()
self.add_module('relu', nn.ReLU(inplace=False))
self.add_module(
'conv',
nn.Conv2d(num_input_features,
num_output_features,
kernel_size=1,
stride=1,
bias=False))
self.add_module(
'norm',
ModuleHelper.BatchNorm2d(bn_type=bn_type)(
num_features=num_output_features)),
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
groups=1,
base_width=64,
dilation=1,
bn_type=None):
super(Bottleneck, self).__init__()
width = int(planes * (base_width / 64.)) * groups
# Both self.conv2 and self.downsample layers downsample the input when stride != 1
self.conv1 = conv1x1(inplanes, width)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(width)
self.conv2 = conv3x3(width, width, stride, groups, dilation)
self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(width)
self.conv3 = conv1x1(width, planes * self.expansion)
self.bn3 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes *
self.expansion)
self.relu = nn.ReLU(inplace=False)
self.relu_in = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def __init__(self, num_classes, bn_type=None):
super(DeepLabHead, self).__init__()
# auxiliary loss
self.layer_dsn = nn.Sequential(
nn.Conv2d(1024, 256, kernel_size=3, stride=1, padding=1),
ModuleHelper.BNReLU(256, bn_type=bn_type),
nn.Conv2d(256,
num_classes,
kernel_size=1,
stride=1,
padding=0,
bias=True))
# main pipeline
self.layer_aspp = ASPPModule(2048, 512, bn_type=bn_type)
self.refine = nn.Sequential(
nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=1,
bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(512),
nn.Conv2d(512, num_classes, kernel_size=1, stride=1, bias=True))
def _make_layer(self,
block,
planes,
blocks,
stride=1,
dilate=False,
bn_type=None):
downsample = None
previous_dilation = self.dilation
if dilate:
self.dilation *= stride
stride = 1
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = nn.Sequential(
conv1x1(self.inplanes, planes * block.expansion, stride),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes *
block.expansion),
)
layers = []
layers.append(
block(self.inplanes,
planes,
stride,
downsample,
self.groups,
self.base_width,
previous_dilation,
bn_type=bn_type))
self.inplanes = planes * block.expansion
for _ in range(1, blocks):
layers.append(
block(self.inplanes,
planes,
groups=self.groups,
base_width=self.base_width,
dilation=self.dilation,
bn_type=bn_type))
return nn.Sequential(*layers)
def _make_one_branch(self,
branch_index,
block,
num_blocks,
num_channels,
stride=1,
bn_type=None,
bn_momentum=0.1):
downsample = None
if stride != 1 or \
self.num_inchannels[branch_index] != num_channels[branch_index] * block.expansion:
downsample = nn.Sequential(
nn.Conv2d(self.num_inchannels[branch_index],
num_channels[branch_index] * block.expansion,
kernel_size=1,
stride=stride,
bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(
num_channels[branch_index] * block.expansion,
momentum=bn_momentum),
)
layers = []
layers.append(
block(self.num_inchannels[branch_index],
num_channels[branch_index],
stride,
downsample,
bn_type=bn_type,
bn_momentum=bn_momentum))
self.num_inchannels[branch_index] = \
num_channels[branch_index] * block.expansion
for i in range(1, num_blocks[branch_index]):
layers.append(
block(self.num_inchannels[branch_index],
num_channels[branch_index],
bn_type=bn_type,
bn_momentum=bn_momentum))
return nn.Sequential(*layers)
def _make_layer(self,
block,
inplanes,
planes,
blocks,
stride=1,
bn_type=None,
bn_momentum=0.1):
downsample = None
if stride != 1 or inplanes != planes * block.expansion:
downsample = nn.Sequential(
nn.Conv2d(inplanes,
planes * block.expansion,
kernel_size=1,
stride=stride,
bias=False),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(
planes * block.expansion, momentum=bn_momentum))
layers = []
layers.append(
block(inplanes,
planes,
stride,
downsample,
bn_type=bn_type,
bn_momentum=bn_momentum))
inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(
block(inplanes,
planes,
bn_type=bn_type,
bn_momentum=bn_momentum))
return nn.Sequential(*layers)
def _make_layer(self,
block,
planes,
blocks,
stride=1,
dilation=1,
bn_type=None,
dropblock_prob=0.0,
is_first=True):
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
down_layers = []
if self.avg_down:
if dilation == 1:
down_layers.append(
nn.AvgPool2d(kernel_size=stride,
stride=stride,
ceil_mode=True,
count_include_pad=False))
else:
down_layers.append(
nn.AvgPool2d(kernel_size=1,
stride=1,
ceil_mode=True,
count_include_pad=False))
down_layers.append(
nn.Conv2d(self.inplanes,
planes * block.expansion,
kernel_size=1,
stride=1,
bias=False))
else:
down_layers.append(
nn.Conv2d(self.inplanes,
planes * block.expansion,
kernel_size=1,
stride=stride,
bias=False))
down_layers.append(
ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes *
block.expansion))
downsample = nn.Sequential(*down_layers)
layers = []
if dilation == 1 or dilation == 2:
layers.append(
block(self.inplanes,
planes,
stride,
downsample=downsample,
radix=self.radix,
cardinality=self.cardinality,
bottleneck_width=self.bottleneck_width,
avd=self.avd,
avd_first=self.avd_first,
dilation=1,
is_first=is_first,
rectified_conv=self.rectified_conv,
rectify_avg=self.rectify_avg,
bn_type=bn_type,
dropblock_prob=dropblock_prob,
last_gamma=self.last_gamma))
elif dilation == 4:
layers.append(
block(self.inplanes,
planes,
stride,
downsample=downsample,
radix=self.radix,
cardinality=self.cardinality,
bottleneck_width=self.bottleneck_width,
avd=self.avd,
avd_first=self.avd_first,
dilation=2,
is_first=is_first,
rectified_conv=self.rectified_conv,
rectify_avg=self.rectify_avg,
bn_type=bn_type,
dropblock_prob=dropblock_prob,
last_gamma=self.last_gamma))
else:
raise RuntimeError("=> unknown dilation size: {}".format(dilation))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(
block(self.inplanes,
planes,
radix=self.radix,
cardinality=self.cardinality,
bottleneck_width=self.bottleneck_width,
avd=self.avd,
avd_first=self.avd_first,
dilation=dilation,
rectified_conv=self.rectified_conv,
rectify_avg=self.rectify_avg,
bn_type=bn_type,
dropblock_prob=dropblock_prob,
last_gamma=self.last_gamma))
return nn.Sequential(*layers)
def __init__(self,
block,
layers,
radix=1,
groups=1,
bottleneck_width=64,
num_classes=1000,
dilated=False,
dilation=1,
deep_stem=False,
stem_width=64,
avg_down=False,
rectified_conv=False,
rectify_avg=False,
avd=False,
avd_first=False,
final_drop=0.0,
dropblock_prob=0,
last_gamma=False,
bn_type=None):
self.cardinality = groups
self.bottleneck_width = bottleneck_width
# ResNet-D params
self.inplanes = stem_width * 2 if deep_stem else 64
self.avg_down = avg_down
self.last_gamma = last_gamma
# ResNeSt params
self.radix = radix
self.avd = avd
self.avd_first = avd_first
super(ResNeSt, self).__init__()
self.rectified_conv = rectified_conv
self.rectify_avg = rectify_avg
if rectified_conv:
from rfconv import RFConv2d
conv_layer = RFConv2d
else:
conv_layer = nn.Conv2d
conv_kwargs = {'average_mode': rectify_avg} if rectified_conv else {}
if deep_stem:
self.conv1 = nn.Sequential(
conv_layer(3,
stem_width,
kernel_size=3,
stride=2,
padding=1,
bias=False,
**conv_kwargs),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(stem_width),
nn.ReLU(inplace=False),
conv_layer(stem_width,
stem_width,
kernel_size=3,
stride=1,
padding=1,
bias=False,
**conv_kwargs),
ModuleHelper.BatchNorm2d(bn_type=bn_type)(stem_width),
nn.ReLU(inplace=False),
conv_layer(stem_width,
stem_width * 2,
kernel_size=3,
stride=1,
padding=1,
bias=False,
**conv_kwargs),
)
else:
self.conv1 = conv_layer(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False,
**conv_kwargs)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(self.inplanes)
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],
bn_type=bn_type,
is_first=False)
self.layer2 = self._make_layer(block,
128,
layers[1],
stride=2,
bn_type=bn_type)
if dilated or dilation == 4:
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=1,
dilation=2,
bn_type=bn_type,
dropblock_prob=dropblock_prob)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=1,
dilation=4,
bn_type=bn_type,
dropblock_prob=dropblock_prob)
elif dilation == 2:
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=2,
dilation=1,
bn_type=bn_type,
dropblock_prob=dropblock_prob)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=1,
dilation=2,
bn_type=bn_type,
dropblock_prob=dropblock_prob)
else:
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=2,
bn_type=bn_type,
dropblock_prob=dropblock_prob)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=2,
bn_type=bn_type,
dropblock_prob=dropblock_prob)
self.avgpool = GlobalAvgPool2d()
self.drop = nn.Dropout(final_drop) if final_drop > 0.0 else None
self.fc = nn.Linear(512 * block.expansion, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(
m, ModuleHelper.BatchNorm2d(bn_type=bn_type,
ret_cls=True)):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, block, layers, deep_base=True, bn_type=None):
super(DCNResNet, self).__init__()
# if depth not in self.arch_settings:
# raise KeyError('invalid depth {} for resnet'.format(depth))
# assert num_stages >= 1 and num_stages <= 4
# block, stage_blocks = self.arch_settings[depth]
# stage_blocks = stage_blocks[:num_stages]
# assert len(strides) == len(dilations) == num_stages
# assert max(out_indices) < num_stages
self.style = 'pytorch'
self.inplanes = 128 if deep_base else 64
if deep_base:
self.resinit = nn.Sequential(
OrderedDict([
('conv1',
nn.Conv2d(3,
64,
kernel_size=3,
stride=2,
padding=1,
bias=False)),
('bn1', ModuleHelper.BatchNorm2d(bn_type=bn_type)(64)),
('relu1', nn.ReLU(inplace=False)),
('conv2',
nn.Conv2d(64,
64,
kernel_size=3,
stride=1,
padding=1,
bias=False)),
('bn2', ModuleHelper.BatchNorm2d(bn_type=bn_type)(64)),
('relu2', nn.ReLU(inplace=False)),
('conv3',
nn.Conv2d(64,
128,
kernel_size=3,
stride=1,
padding=1,
bias=False)),
('bn3',
ModuleHelper.BatchNorm2d(bn_type=bn_type)(self.inplanes)),
('relu3', nn.ReLU(inplace=False))
]))
else:
self.resinit = nn.Sequential(
OrderedDict([
('conv1',
nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('bn1',
ModuleHelper.BatchNorm2d(bn_type=bn_type)(self.inplanes)),
('relu1', nn.ReLU(inplace=False))
]))
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = make_res_layer(block,
self.inplanes,
64,
layers[0],
style=self.style,
with_dcn=False,
use_modulated_dcn=False,
bn_type=bn_type)
self.layer2 = make_res_layer(block,
256,
128,
layers[1],
stride=2,
style=self.style,
with_dcn=False,
use_modulated_dcn=False,
bn_type=bn_type)
self.layer3 = make_res_layer(block,
512,
256,
layers[2],
stride=2,
style=self.style,
with_dcn=True,
use_modulated_dcn=False,
bn_type=bn_type)
self.layer4 = make_res_layer(block,
1024,
512,
layers[3],
stride=2,
style=self.style,
with_dcn=True,
use_modulated_dcn=False,
bn_type=bn_type)
def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
radix=1,
cardinality=1,
bottleneck_width=64,
avd=False,
avd_first=False,
dilation=1,
is_first=False,
rectified_conv=False,
rectify_avg=False,
bn_type=None,
dropblock_prob=0.0,
last_gamma=False):
super(Bottleneck, self).__init__()
group_width = int(planes * (bottleneck_width / 64.)) * cardinality
self.conv1 = nn.Conv2d(inplanes,
group_width,
kernel_size=1,
bias=False)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(group_width)
self.dropblock_prob = dropblock_prob
self.radix = radix
self.avd = avd and (stride > 1 or is_first)
self.avd_first = avd_first
if self.avd:
self.avd_layer = nn.AvgPool2d(3, stride, padding=1)
stride = 1
if dropblock_prob > 0.0:
self.dropblock1 = DropBlock2D(dropblock_prob, 3)
if radix == 1:
self.dropblock2 = DropBlock2D(dropblock_prob, 3)
self.dropblock3 = DropBlock2D(dropblock_prob, 3)
if radix > 1:
self.conv2 = SplAtConv2d(group_width,
group_width,
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
groups=cardinality,
bias=False,
radix=radix,
rectify=rectified_conv,
rectify_avg=rectify_avg,
bn_type=bn_type,
dropblock_prob=dropblock_prob)
elif rectified_conv:
from rfconv import RFConv2d
self.conv2 = RFConv2d(group_width,
group_width,
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
groups=cardinality,
bias=False,
average_mode=rectify_avg)
self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(group_width)
else:
self.conv2 = nn.Conv2d(group_width,
group_width,
kernel_size=3,
stride=stride,
padding=dilation,
dilation=dilation,
groups=cardinality,
bias=False)
self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(group_width)
self.conv3 = nn.Conv2d(group_width,
planes * 4,
kernel_size=1,
bias=False)
self.bn3 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes * 4)
if last_gamma:
from torch.nn.init import zeros_
zeros_(self.bn3.weight)
self.relu = nn.ReLU(inplace=False)
self.relu_in = nn.ReLU(inplace=True)
self.downsample = downsample
self.dilation = dilation
self.stride = stride
def __init__(self,
block,
layers,
num_classes=1000,
deep_base=False,
bn_type=None):
super(ResNet, self).__init__()
self.inplanes = 128 if deep_base else 64
if deep_base:
self.resinit = nn.Sequential(
OrderedDict([
('conv1',
nn.Conv2d(3,
64,
kernel_size=3,
stride=2,
padding=1,
bias=False)),
('bn1', ModuleHelper.BatchNorm2d(bn_type=bn_type)(64)),
('relu1', nn.ReLU(inplace=False)),
('conv2',
nn.Conv2d(64,
64,
kernel_size=3,
stride=1,
padding=1,
bias=False)),
('bn2', ModuleHelper.BatchNorm2d(bn_type=bn_type)(64)),
('relu2', nn.ReLU(inplace=False)),
('conv3',
nn.Conv2d(64,
128,
kernel_size=3,
stride=1,
padding=1,
bias=False)),
('bn3',
ModuleHelper.BatchNorm2d(bn_type=bn_type)(self.inplanes)),
('relu3', nn.ReLU(inplace=False))
]))
else:
self.resinit = nn.Sequential(
OrderedDict([
('conv1',
nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('bn1',
ModuleHelper.BatchNorm2d(bn_type=bn_type)(self.inplanes)),
('relu1', 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], bn_type=bn_type)
self.layer2 = self._make_layer(block,
128,
layers[1],
stride=2,
bn_type=bn_type)
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=2,
bn_type=bn_type)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=2,
bn_type=bn_type)
self.avgpool = nn.AvgPool2d(7, stride=1)
self.fc = nn.Linear(512 * block.expansion, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(
m, ModuleHelper.BatchNorm2d(bn_type=bn_type,
ret_cls=True)):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self,
inplanes,
planes,
stride=1,
dilation=1,
downsample=None,
style='pytorch',
with_cp=False,
with_dcn=False,
num_deformable_groups=1,
dcn_offset_lr_mult=0.1,
use_regular_conv_on_stride=False,
use_modulated_dcn=False,
bn_type=None):
"""Bottleneck block.
If style is "pytorch", the stride-two layer is the 3x3 conv layer,
if it is "caffe", the stride-two layer is the first 1x1 conv layer.
"""
super(Bottleneck, self).__init__()
conv1_stride = 1
conv2_stride = stride
self.conv1 = nn.Conv2d(inplanes,
planes,
kernel_size=1,
stride=conv1_stride,
bias=False)
self.with_dcn = with_dcn
self.use_modulated_dcn = use_modulated_dcn
if use_regular_conv_on_stride and stride > 1:
self.with_dcn = False
if self.with_dcn:
print("--->> use {}dcn in block where c_in={} and c_out={}".format(
'modulated ' if self.use_modulated_dcn else '', planes,
inplanes))
if use_modulated_dcn:
self.conv_offset_mask = nn.Conv2d(planes,
num_deformable_groups * 27,
kernel_size=3,
stride=conv2_stride,
padding=dilation,
dilation=dilation)
self.conv_offset_mask.lr_mult = dcn_offset_lr_mult
self.conv_offset_mask.zero_init = True
self.conv2 = ModulatedDeformConv(
planes,
planes,
3,
stride=conv2_stride,
padding=dilation,
dilation=dilation,
deformable_groups=num_deformable_groups,
no_bias=True)
else:
self.conv2_offset = nn.Conv2d(planes,
num_deformable_groups * 18,
kernel_size=3,
stride=conv2_stride,
padding=dilation,
dilation=dilation)
self.conv2_offset.lr_mult = dcn_offset_lr_mult
self.conv2_offset.zero_init = True
self.conv2 = DeformConv(
planes,
planes, (3, 3),
stride=conv2_stride,
padding=dilation,
dilation=dilation,
num_deformable_groups=num_deformable_groups)
else:
self.conv2 = nn.Conv2d(planes,
planes,
kernel_size=3,
stride=conv2_stride,
padding=dilation,
dilation=dilation,
bias=False)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes)
self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes)
self.conv3 = nn.Conv2d(planes,
planes * self.expansion,
kernel_size=1,
bias=False)
self.bn3 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(planes *
self.expansion)
self.relu = nn.ReLU(inplace=False)
self.relu_in = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
self.dilation = dilation
self.with_cp = with_cp
def __init__(self, cfg, bn_type, **kwargs):
super(HighResolutionNext, self).__init__()
# stem net
self.conv1 = nn.Conv2d(3,
64,
kernel_size=3,
stride=2,
padding=1,
bias=False)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(64)
self.relu = nn.ReLU(relu_inplace)
self.stage1_cfg = cfg['STAGE1']
num_channels = self.stage1_cfg['NUM_CHANNELS']
block = blocks_dict[self.stage1_cfg['BLOCK']]
num_channels = [
num_channels[i] * block.expansion for i in range(len(num_channels))
]
self.transition0 = self._make_transition_layer([64],
num_channels,
bn_type=bn_type)
self.stage1, pre_stage_channels = self._make_stage(self.stage1_cfg,
num_channels,
bn_type=bn_type)
self.stage2_cfg = cfg['STAGE2']
num_channels = self.stage2_cfg['NUM_CHANNELS']
block = blocks_dict[self.stage2_cfg['BLOCK']]
num_channels = [
num_channels[i] * block.expansion for i in range(len(num_channels))
]
self.transition1 = self._make_transition_layer(pre_stage_channels,
num_channels,
bn_type=bn_type)
self.stage2, pre_stage_channels = self._make_stage(self.stage2_cfg,
num_channels,
bn_type=bn_type)
self.stage3_cfg = cfg['STAGE3']
num_channels = self.stage3_cfg['NUM_CHANNELS']
block = blocks_dict[self.stage3_cfg['BLOCK']]
num_channels = [
num_channels[i] * block.expansion for i in range(len(num_channels))
]
self.transition2 = self._make_transition_layer(pre_stage_channels,
num_channels,
bn_type=bn_type)
self.stage3, pre_stage_channels = self._make_stage(self.stage3_cfg,
num_channels,
bn_type=bn_type)
self.stage4_cfg = cfg['STAGE4']
num_channels = self.stage4_cfg['NUM_CHANNELS']
block = blocks_dict[self.stage4_cfg['BLOCK']]
num_channels = [
num_channels[i] * block.expansion for i in range(len(num_channels))
]
self.transition3 = self._make_transition_layer(pre_stage_channels,
num_channels,
bn_type=bn_type)
self.stage4, pre_stage_channels = self._make_stage(
self.stage4_cfg,
num_channels,
multi_scale_output=True,
bn_type=bn_type)
def __init__(self,
block,
layers,
num_classes=1000,
zero_init_residual=False,
groups=1,
width_per_group=64,
replace_stride_with_dilation=None,
bn_type=None):
super(ResNet, self).__init__()
self.inplanes = 64
self.dilation = 1
if replace_stride_with_dilation is None:
# each element in the tuple indicates if we should replace
# the 2x2 stride with a dilated convolution instead
replace_stride_with_dilation = [False, False, False]
if len(replace_stride_with_dilation) != 3:
raise ValueError("replace_stride_with_dilation should be None "
"or a 3-element tuple, got {}".format(
replace_stride_with_dilation))
self.groups = groups
self.base_width = width_per_group
self.resinit = nn.Sequential(
OrderedDict([
('conv1',
nn.Conv2d(3,
self.inplanes,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('bn1',
ModuleHelper.BatchNorm2d(bn_type=bn_type)(self.inplanes)),
('relu1', nn.ReLU(inplace=False))
]))
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0], bn_type=bn_type)
self.layer2 = self._make_layer(block,
128,
layers[1],
stride=2,
dilate=replace_stride_with_dilation[0],
bn_type=bn_type)
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=2,
dilate=replace_stride_with_dilation[1],
bn_type=bn_type)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=2,
dilate=replace_stride_with_dilation[2],
bn_type=bn_type)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512 * block.expansion, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight,
mode='fan_out',
nonlinearity='relu')
elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
# Zero-initialize the last BN in each residual branch,
# so that the residual branch starts with zeros, and each residual block behaves like an identity.
# This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
if zero_init_residual:
for m in self.modules():
if isinstance(m, Bottleneck):
nn.init.constant_(m.bn3.weight, 0)
elif isinstance(m, BasicBlock):
nn.init.constant_(m.bn2.weight, 0)
def __init__(self, configer):
super(DenseASPP, self).__init__()
self.configer = configer
dropout0 = 0.1
dropout1 = 0.1
self.backbone = BackboneSelector(configer).get_backbone()
num_features = self.backbone.get_num_features()
self.trans = _Transition(num_input_features=self.num_features,
num_output_features=self.num_features // 2,
bn_type=self.configer.get(
'network', 'bn_type'))
self.num_features = self.num_features // 2
self.ASPP_3 = _DenseAsppBlock(input_num=num_features,
num1=256,
num2=64,
dilation_rate=3,
drop_out=dropout0,
bn_type=self.configer.get(
'network', 'bn_type'))
self.ASPP_6 = _DenseAsppBlock(input_num=num_features + 64 * 1,
num1=256,
num2=64,
dilation_rate=6,
drop_out=dropout0,
bn_type=self.configer.get(
'network', 'bn_type'))
self.ASPP_12 = _DenseAsppBlock(input_num=num_features + 64 * 2,
num1=256,
num2=64,
dilation_rate=12,
drop_out=dropout0,
bn_type=self.configer.get(
'network', 'bn_type'))
self.ASPP_18 = _DenseAsppBlock(input_num=num_features + 64 * 3,
num1=256,
num2=64,
dilation_rate=18,
drop_out=dropout0,
bn_type=self.configer.get(
'network', 'bn_type'))
self.ASPP_24 = _DenseAsppBlock(input_num=num_features + 64 * 4,
num1=256,
num2=64,
dilation_rate=24,
drop_out=dropout0,
bn_type=self.configer.get(
'network', 'bn_type'))
num_features = num_features + 5 * 64
self.classification = nn.Sequential(
nn.Dropout2d(p=dropout1),
nn.Conv2d(in_channels=num_features,
out_channels=self.configer.get('network',
'out_channels'),
kernel_size=1,
padding=0))
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.xavier_uniform_(m.weight.data)
elif isinstance(
m,
ModuleHelper.BatchNorm2d(
bn_type=self.configer.get('network', 'bn_type'))):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, cfg, bn_type, bn_momentum, **kwargs):
self.inplanes = 64
super(HighResolutionNet, self).__init__()
if os.environ.get('full_res_stem'):
Log.info("using full-resolution stem with stride=1")
stem_stride = 1
self.conv1 = nn.Conv2d(3,
64,
kernel_size=3,
stride=stem_stride,
padding=1,
bias=False)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(
64, momentum=bn_momentum)
self.relu = nn.ReLU(inplace=False)
self.layer1 = self._make_layer(Bottleneck,
64,
64,
4,
bn_type=bn_type,
bn_momentum=bn_momentum)
else:
stem_stride = 2
self.conv1 = nn.Conv2d(3,
64,
kernel_size=3,
stride=stem_stride,
padding=1,
bias=False)
self.bn1 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(
64, momentum=bn_momentum)
self.conv2 = nn.Conv2d(64,
64,
kernel_size=3,
stride=stem_stride,
padding=1,
bias=False)
self.bn2 = ModuleHelper.BatchNorm2d(bn_type=bn_type)(
64, momentum=bn_momentum)
self.relu = nn.ReLU(inplace=False)
self.layer1 = self._make_layer(Bottleneck,
64,
64,
4,
bn_type=bn_type,
bn_momentum=bn_momentum)
self.stage2_cfg = cfg['STAGE2']
num_channels = self.stage2_cfg['NUM_CHANNELS']
block = blocks_dict[self.stage2_cfg['BLOCK']]
num_channels = [
num_channels[i] * block.expansion for i in range(len(num_channels))
]
self.transition1 = self._make_transition_layer([256],
num_channels,
bn_type=bn_type,
bn_momentum=bn_momentum)
self.stage2, pre_stage_channels = self._make_stage(
self.stage2_cfg,
num_channels,
bn_type=bn_type,
bn_momentum=bn_momentum)
self.stage3_cfg = cfg['STAGE3']
num_channels = self.stage3_cfg['NUM_CHANNELS']
block = blocks_dict[self.stage3_cfg['BLOCK']]
num_channels = [
num_channels[i] * block.expansion for i in range(len(num_channels))
]
self.transition2 = self._make_transition_layer(pre_stage_channels,
num_channels,
bn_type=bn_type,
bn_momentum=bn_momentum)
self.stage3, pre_stage_channels = self._make_stage(
self.stage3_cfg,
num_channels,
bn_type=bn_type,
bn_momentum=bn_momentum)
self.stage4_cfg = cfg['STAGE4']
num_channels = self.stage4_cfg['NUM_CHANNELS']
block = blocks_dict[self.stage4_cfg['BLOCK']]
num_channels = [
num_channels[i] * block.expansion for i in range(len(num_channels))
]
self.transition3 = self._make_transition_layer(pre_stage_channels,
num_channels,
bn_type=bn_type,
bn_momentum=bn_momentum)
self.stage4, pre_stage_channels = self._make_stage(
self.stage4_cfg,
num_channels,
multi_scale_output=True,
bn_type=bn_type,
bn_momentum=bn_momentum,
last=True)
if os.environ.get('keep_imagenet_head'):
self.incre_modules, self.downsamp_modules, \
self.final_layer = self._make_head(pre_stage_channels, bn_type=bn_type, bn_momentum=bn_momentum)
