def __init__(self,
inplanes,
planes,
stride=1,
downsample=None,
baseWidth=26,
scale=4,
stype='normal'):
""" Constructor
Args:
inplanes: input channel dimensionality
planes: output channel dimensionality
stride: conv stride. Replaces pooling layer.
downsample: None when stride = 1
baseWidth: basic width of conv3x3
scale: number of scale.
type: 'normal': normal set. 'stage': first block of a new stage.
"""
super(Bottle2neck, self).__init__()
width = int(math.floor(planes * (baseWidth / 64.0)))
self.conv1 = nn.Conv2d(inplanes,
width * scale,
kernel_size=1,
bias=False)
self.bn1 = BatchNorm2d(width * scale)
if scale == 1:
self.nums = 1
else:
self.nums = scale - 1
if stype == 'stage':
self.pool = nn.AvgPool2d(kernel_size=3, stride=stride, padding=1)
convs = []
bns = []
for i in range(self.nums):
convs.append(
nn.Conv2d(width,
width,
kernel_size=3,
stride=stride,
padding=1,
bias=False))
bns.append(BatchNorm2d(width))
self.convs = nn.ModuleList(convs)
self.bns = nn.ModuleList(bns)
self.conv3 = nn.Conv2d(width * scale,
planes * self.expansion,
kernel_size=1,
bias=False)
self.bn3 = BatchNorm2d(planes * self.expansion)
self.relu = relu_fn
self.downsample = downsample
self.stype = stype
self.scale = scale
self.width = width
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(BasicBlock, self).__init__()
self.conv1 = conv3x3(inplanes, planes, stride)
self.bn1 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
self.relu = relu_fn
self.conv2 = conv3x3(planes, planes)
self.bn2 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
self.downsample = downsample
self.stride = stride
def _make_deconv_layer(self, num_layers, num_filters, num_kernels):
assert num_layers == len(num_filters), \
'ERROR: num_deconv_layers is different len(num_deconv_filters)'
assert num_layers == len(num_kernels), \
'ERROR: num_deconv_layers is different len(num_deconv_filters)'
layers = []
in_channels = self.inplanes
for i in range(num_layers): # 只3个？
kernel, padding, output_padding = \
self._get_deconv_cfg(num_kernels[i], i) # 返回4 1 0
planes = num_filters[i] # 256 256 256
layers.append(
nn.Sequential(
DwTrans(in_channels,
out_channels=planes,
kernel_size=kernel,
stride=2,
padding=padding,
output_padding=output_padding,
bias=self.deconv_with_bias),
BatchNorm2d(planes, momentum=BN_MOMENTUM),
# nn.ReLU(inplace=True),
# 新增后面的卷积
# nn.Conv2d(256,256,3,1,1),
# BatchNorm2d(256, momentum=BN_MOMENTUM),
# nn.ReLU(inplace=True),
# nn.Conv2d(256,256,3,1,1),
# BatchNorm2d(256, momentum=BN_MOMENTUM),
# nn.ReLU(inplace=True),
))
in_channels = planes
return nn.ModuleList(layers) # 【see】改
def _make_layer(self, block, planes, blocks, stride=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, momentum=BN_MOMENTUM),
)
layers = []
layers.append(
block(self.inplanes,
planes,
stride,
downsample=downsample,
stype='stage',
baseWidth=self.baseWidth,
scale=self.scale))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(
block(self.inplanes,
planes,
baseWidth=self.baseWidth,
scale=self.scale))
return nn.Sequential(*layers)
def __init__(self, block, layers, cfg, **kwargs):
self.inplanes = 64
self.baseWidth = cfg.MODEL.BASEWIDTH
self.scale = cfg.MODEL.SCALE
extra = cfg.MODEL.EXTRA
self.deconv_with_bias = extra.DECONV_WITH_BIAS
self.method = extra.LOSS_TYPE
super(PoseRes2Net, self).__init__()
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = BatchNorm2d(64, momentum=BN_MOMENTUM)
self.relu = relu_fn
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2) # 4
self.deconv_layers2 = self._make_deconv_layer(
extra.STAGE2.NUM_DECONV_LAYERS, # 3
extra.STAGE2.NUM_DECONV_FILTERS, # 256 256 256
extra.STAGE2.NUM_DECONV_KERNELS, # 4 4 4
)
# self.change_channel_2 =nn.Conv2d(
# in_channels=512, # 【】把deconv改为resnet对应的通道数
# out_channels=256,
# kernel_size=1, # 1
# stride=1,
# padding=0
# )
self.layer3 = self._make_layer(block, 256, layers[2], stride=2) # 6
self.deconv_layers3 = self._make_deconv_layer(
extra.STAGE3.NUM_DECONV_LAYERS, # 3
extra.STAGE3.NUM_DECONV_FILTERS, # 256 256 256
extra.STAGE3.NUM_DECONV_KERNELS, # 4 4 4
)
# self.change_channel_3 =nn.Conv2d(#参数量太大了：只有1M
# in_channels=1024, # 【】把deconv改为resnet对应的通道数
# out_channels=256,
# kernel_size=1, # 1
# stride=1,
# padding=0
# )
self.layer4 = self._make_layer(block, 512, layers[3], stride=2) # 3
self.deconv_layers4 = self._make_deconv_layer(
extra.STAGE4.NUM_DECONV_LAYERS, # 3
extra.STAGE4.NUM_DECONV_FILTERS, # 256 256 256
extra.STAGE4.NUM_DECONV_KERNELS, # 4 4 4
)
# used for deconv layers
self.channel_att2 = SEBlock(16, 1)
self.channel_att3 = SEBlock(16, 1)
self.channel_att4 = SEBlock(16, 1)
self.final_layer = nn.Conv2d(
in_channels=extra.STAGE4.NUM_DECONV_FILTERS[-1],
out_channels=cfg.MODEL.NUM_JOINTS,
kernel_size=extra.FINAL_CONV_KERNEL,
stride=1,
padding=1 if extra.FINAL_CONV_KERNEL == 3 else 0)
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(Bottleneck, self).__init__()
self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
self.bn1 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
self.conv2 = nn.Conv2d(planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn2 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
self.conv3 = nn.Conv2d(planes,
planes * self.expansion,
kernel_size=1,
bias=False)
self.bn3 = BatchNorm2d(planes * self.expansion, momentum=BN_MOMENTUM)
self.relu = relu_fn
self.downsample = downsample
self.stride = stride
def _change_channel(self,inplane,outplane):
change_channel = nn.Sequential(
nn.Conv2d(
in_channels=inplane, # 【】把deconv改为resnet对应的通道数
out_channels=outplane,
kernel_size=1, # 1
stride=1,
padding=0
),
BatchNorm2d(outplane,momentum=BN_MOMENTUM)
)
return change_channel
def __init__(self, block_args, global_params):
super().__init__()
self._block_args = block_args
self._bn_mom = 1 - global_params.batch_norm_momentum
self._bn_eps = global_params.batch_norm_epsilon
self.has_se = (self._block_args.se_ratio is not None) and (0 < self._block_args.se_ratio <= 1)
self.id_skip = block_args.id_skip # skip connection and drop connect
# Get static or dynamic convolution depending on image size
Conv2d = get_same_padding_conv2d(image_size=global_params.image_size)
# Expansion phase
inp = self._block_args.input_filters # number of input channels
oup = self._block_args.input_filters * self._block_args.expand_ratio # number of output channels
if self._block_args.expand_ratio != 1:
self._expand_conv = Conv2d(in_channels=inp, out_channels=oup, kernel_size=1, bias=False)
self._bn0 = BatchNorm2d(num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
# Depthwise convolution phase
k = self._block_args.kernel_size
s = self._block_args.stride
self._depthwise_conv = Conv2d(
in_channels=oup, out_channels=oup, groups=oup, # groups makes it depthwise
kernel_size=k, stride=s, bias=False)
self._bn1 = BatchNorm2d(num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
# Squeeze and Excitation layer, if desired
if self.has_se:
num_squeezed_channels = max(1, int(self._block_args.input_filters * self._block_args.se_ratio))
self._se_reduce = Conv2d(in_channels=oup, out_channels=num_squeezed_channels, kernel_size=1)
self._se_expand = Conv2d(in_channels=num_squeezed_channels, out_channels=oup, kernel_size=1)
# Output phase
final_oup = self._block_args.output_filters
self._project_conv = Conv2d(in_channels=oup, out_channels=final_oup, kernel_size=1, bias=False)
self._bn2 = BatchNorm2d(num_features=final_oup, momentum=self._bn_mom, eps=self._bn_eps)
def __init__(self, cfg,blocks_args=None, global_params=None,**kwargs):#不会被前面两个参数干扰了吧
super().__init__()
assert isinstance(blocks_args, list), 'blocks_args should be a list'
assert len(blocks_args) > 0, 'block args must be greater than 0'
self._global_params = global_params
self._blocks_args = blocks_args
#【see】
# self.inplanes = 320#deconv前的通道数
extra = cfg.MODEL.EXTRA
self.deconv_with_bias = extra.DECONV_WITH_BIAS # false
self.relu = nn.ReLU(inplace=True)
# Get static or dynamic convolution depending on image size
Conv2d = get_same_padding_conv2d(image_size=global_params.image_size)
# Batch norm parameters
bn_mom = 1 - self._global_params.batch_norm_momentum
bn_eps = self._global_params.batch_norm_epsilon
# Stem
in_channels = 3 # rgb
out_channels = round_filters(32, self._global_params) # number of output channels
self._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False)
self._bn0 = BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps)
# Build blocks
self._blocks = nn.ModuleList([])
for block_args in self._blocks_args:
# Update block input and output filters based on depth multiplier.
block_args = block_args._replace(
input_filters=round_filters(block_args.input_filters, self._global_params),
output_filters=round_filters(block_args.output_filters, self._global_params),
num_repeat=round_repeats(block_args.num_repeat, self._global_params)
)
# The first block needs to take care of stride and filter size increase.
self._blocks.append(MBConvBlock(block_args, self._global_params))
if block_args.num_repeat > 1:
block_args = block_args._replace(input_filters=block_args.output_filters, stride=1)
for _ in range(block_args.num_repeat - 1):
self._blocks.append(MBConvBlock(block_args, self._global_params))
#【see】
self.method = extra.LOSS_TYPE
self.outplane_idx = extra.OUTPLANE_IDX
# print(self.outplane_idx)
# self.deconv_layers2 = self._make_deconv_layer(
# extra.STAGE2.NUM_DECONV_LAYERS, # 3
# extra.STAGE2.NUM_DECONV_FILTERS, # 256 256 256
# extra.STAGE2.NUM_DECONV_KERNELS, # 4 4 4
# extra.DECONV_INCHANNELS[0]
# )
self.deconv_layers3 = self._make_deconv_layer(
extra.STAGE3.NUM_DECONV_LAYERS, # 3
extra.STAGE3.NUM_DECONV_FILTERS, # 256 256 256
extra.STAGE3.NUM_DECONV_KERNELS, # 4 4 4
extra.DECONV_INCHANNELS[1]
)
# self. change_channel_2 = self._change_channel(extra.DECONV_INCHANNELS[0],256)
# self. change_channel_3 = self._change_channel(extra.DECONV_INCHANNELS[1],256)
self.deconv_layers4 = self._make_deconv_layer(
extra.STAGE4.NUM_DECONV_LAYERS, # 3
extra.STAGE4.NUM_DECONV_FILTERS, # 256 256 256
extra.STAGE4.NUM_DECONV_KERNELS, # 4 4 4
extra.DECONV_INCHANNELS[2]
)
self.deconv_layers5 = self._make_deconv_layer(
extra.STAGE5.NUM_DECONV_LAYERS, # 5
extra.STAGE5.NUM_DECONV_FILTERS, # 256 256 256
extra.STAGE5.NUM_DECONV_KERNELS, # 4 4 4
extra.DECONV_INCHANNELS[3]
)
self.final_layer = nn.Conv2d(
in_channels=extra.STAGE4.NUM_DECONV_FILTERS[-1], # 256
out_channels=cfg.MODEL.NUM_JOINTS,
kernel_size=extra.FINAL_CONV_KERNEL, # 1
stride=1,
padding=1 if extra.FINAL_CONV_KERNEL == 3 else 0 # 0
)
# self.channel_att = SEBlock(cfg.MODEL.NUM_JOINTS,16)
self.channel_att2 = SEBlock(64,2)
self.channel_att3 = SEBlock(64,2)
self.channel_att4 = SEBlock(64,2)
self.channel_att5 = SEBlock(64,2)