def _make_layer(self, planes, num_blocks, stride):
layers = []
for i in range(num_blocks):
s = stride if i == 0 else 1
downsample = None
if self.in_planes != planes or s != 1:
downsample = conv1x1(self.in_planes,
planes * BasicBlock.expansion,
stride=s)
layers.append(
BasicBlock(self.in_planes,
planes,
stride=s,
downsample=downsample,
norm_layer=nn.Identity))
self.in_planes = planes * BasicBlock.expansion
return nn.Sequential(*layers)
def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
norm_layer = self._norm_layer
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), norm_layer(planes * block.expansion), )
layers = []
layers.append(block(inplanes = self.inplanes, planes= planes, stride=stride, downsample = downsample, groups= self.groups, base_width = self.base_width, dilation = previous_dilation, norm_layer = norm_layer))
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, norm_layer=norm_layer))
return nn.Sequential(*layers)
def __init__(self, in_c, out_c, batchnorm=True, activation=True, k=3):
super().__init__()
if k == 3:
self.conv = conv3x3(in_c, out_c)
elif k == 1:
self.conv = conv1x1(in_c, out_c)
else:
raise ValueError()
if batchnorm:
self.bn = nn.BatchNorm2d(out_c)
else:
self.bn = nn.Identity()
if activation:
self.relu = nn.ReLU()
else:
self.relu = nn.Identity()
def __init__(self,
block,
layers,
num_classes=1000,
zero_init_residual=False,
groups=1,
width_per_group=64,
replace_stride_with_dilation=None,
norm_layer=None,
out_dim=128):
super().__init__(block, layers, num_classes, zero_init_residual,
groups, width_per_group, replace_stride_with_dilation,
norm_layer)
if norm_layer is None:
norm_layer = nn.BatchNorm2d
self.level_conv = ConvBnRelu(3, 64)
'''
# For reference:
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
dilate=replace_stride_with_dilation[0])
self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
dilate=replace_stride_with_dilation[1])
self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
dilate=replace_stride_with_dilation[2])
'''
uplayers = []
inplanes = 2048
first = True
div = [2, 2, 2, 4, 1]
for i in range(5):
uplayers.append(
ReverseBottleneck(inplanes,
inplanes // div[i],
norm_layer=norm_layer,
passthrough=not first))
inplanes = inplanes // div[i]
first = False
self.uplayers = nn.ModuleList(uplayers)
self.tail = nn.Sequential(conv3x3(128, 64), norm_layer(64), nn.ReLU(),
conv1x1(64, out_dim))
del self.fc # Not used in this implementation and just consumes a ton of GPU memory.
def get_network(nf, nf2, n_classes):
"""
"""
ds = nn.Sequential(
conv1x1(nf, nf2),
nn.AvgPool2d(2),
)
resblock1 = BasicBlock(inplanes=nf, planes=nf2, stride=2, downsample=ds)
resblock2 = BasicBlock(inplanes=nf2,
planes=nf2,
stride=2,
downsample=nn.AvgPool2d(2))
fn = nn.Sequential(
resblock1,
resblock2,
nn.AdaptiveAvgPool2d(1),
Flatten(),
nn.Linear(nf2, n_classes),
)
return fn
def _make_layer(self,
block,
planes: int,
blocks: int,
stride: int = 1,
dilate: bool = False) -> nn.Sequential:
norm_layer = self._norm_layer
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),
norm_layer(planes * block.expansion),
)
layers = []
sd_prob = 1.0 - self.prob_delta * self.layer_num
layers.append(
block(self.inplanes, planes, stride, downsample, self.groups,
self.base_width, previous_dilation, norm_layer,
self.dropout_prob, sd_prob))
self.layer_num += 1
self.inplanes = planes * block.expansion
for _ in range(1, blocks):
sd_prob = 1.0 - self.prob_delta * self.layer_num
layers.append(
block(self.inplanes,
planes,
groups=self.groups,
base_width=self.base_width,
dilation=self.dilation,
norm_layer=norm_layer,
dropout_prob=self.dropout_prob,
stochastic_depth_prob=sd_prob))
self.layer_num += 1
return nn.Sequential(*layers)
def _make_layer(
self,
block: Type[Union[BasicBlock, Bottleneck]],
planes: int,
blocks: int,
stride: int = 1,
):
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = nn.Sequential(
conv1x1(self.inplanes, planes * block.expansion, stride),
nn.BatchNorm2d(planes * block.expansion),
)
layers = []
layers.append(block(self.inplanes, planes, stride, downsample))
self.inplanes = planes * block.expansion
for _ in range(1, blocks):
layers.append(block(self.inplanes, planes))
return nn.Sequential(*layers)
def _make_layer(self, block, planes, blocks, stride=1):
"""Creates a concatenation of blocks in the ResNet.
This function is similar to the one in torchvision/resnets.
https://pytorch.org/vision/0.8/_modules/torchvision/models/resnet.html
Args:
block: basic block to use (with one skip connection)
planes: number of parallel planes
blocks: number of sequential blocks
stride: factor between input and output planes
Returns:
a sequence of blocks
"""
norm_layer = BatchNorm2d
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = Sequential(
conv1x1(self.inplanes, planes * block.expansion, stride),
norm_layer(planes * block.expansion),
)
layers = [
block(self.inplanes, planes, stride, downsample, 1, 64, 1,
norm_layer)
]
self.inplanes = planes * block.expansion
layers += [
block(
self.inplanes,
planes,
groups=1,
base_width=64,
dilation=1,
norm_layer=norm_layer,
) for _ in range(1, blocks)
]
return Sequential(*layers)
def _make_layer(self,
block,
planes,
blocks,
stride=1,
dilate=False,
multi_grid=None):
norm_layer = self._norm_layer
downsample = None
previous_dilation = self.dilation
if multi_grid is None:
multi_grid = [1 for _ in range(blocks)]
else:
assert len(multi_grid) == blocks
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),
norm_layer(planes * block.expansion),
)
layers = []
layers.append(
block(self.inplanes, planes, stride, downsample, self.groups,
self.base_width, previous_dilation * multi_grid[0]))
self.inplanes = planes * block.expansion
for i in range(1, blocks):
layers.append(
block(self.inplanes,
planes,
groups=self.groups,
base_width=self.base_width,
dilation=self.dilation * multi_grid[i],
norm_layer=norm_layer))
return nn.Sequential(*layers)
def _make_layer(self, block, planes, blocks, stride=1, dilate=False):
norm_layer = self._norm_layer
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(*[
nn.AvgPool2d(2, 2, ceil_mode=True, count_include_pad=False),
conv1x1(self.inplanes, planes * block.expansion, stride=1),
norm_layer(planes * block.expansion),
])
layers = []
layers.append(
block(
self.inplanes,
planes,
stride,
downsample,
self.groups,
self.base_width,
previous_dilation,
norm_layer,
))
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,
norm_layer=norm_layer,
))
return nn.Sequential(*layers)
def __init__(self, layout, num_classes=20, anchors=None, lambda_noobj=0.5, lambda_coords=5.,
backbone_norm_layer=None):
super().__init__()
# Priors computed using K-means
if anchors is None:
anchors = torch.tensor([[1.08, 1.19], [3.42, 4.41], [6.63, 11.38], [9.42, 5.11], [16.62, 10.52]])
self.num_classes = num_classes
self.backbone = DarknetBodyV2(layout, True, backbone_norm_layer)
self.reorg_layer = ConcatDownsample2d(scale_factor=2)
self.block5 = nn.Sequential(
conv3x3(layout[-1][0], layout[-1][0]),
nn.BatchNorm2d(layout[-1][0]),
nn.LeakyReLU(0.1, inplace=True),
conv3x3(layout[-1][0], layout[-1][0]),
nn.BatchNorm2d(layout[-1][0]),
nn.LeakyReLU(0.1, inplace=True))
self.block6 = nn.Sequential(
conv3x3(layout[-1][0] + layout[-2][0] * 2 ** 2, layout[-1][0]),
nn.BatchNorm2d(layout[-1][0]),
nn.LeakyReLU(0.1, inplace=True))
# Each box has P_objectness, 4 coords, and score for each class
self.head = conv1x1(layout[-1][0], anchors.shape[0] * (5 + num_classes))
# Register losses
self.register_buffer('anchors', anchors)
# Loss coefficients
self.lambda_noobj = lambda_noobj
self.lambda_coords = lambda_coords
init_module(self, 'leaky_relu')
def _make_layer(block,
in_dim,
out_dim,
blocks,
stride=1,
norm_layer=None,
is_first=False,
is_last=False):
if norm_layer is None:
norm_layer = nn.BatchNorm2d
if is_last:
return [
nn.AvgPool2d(in_dim[1:]),
Flatten(),
nn.Linear(in_dim[0], out_dim)
]
in_planes = in_dim[0]
planes = out_dim[0]
if is_first:
return [conv3x3(in_planes, planes), norm_layer(planes), nn.ReLU()]
downsample = None
if stride != 1 or in_planes != planes * block.expansion:
downsample = nn.Sequential(
conv1x1(in_planes, planes * block.expansion, stride),
norm_layer(planes * block.expansion),
)
layers = []
layers.append(block(in_planes, planes, stride, downsample, norm_layer))
in_planes = planes * block.expansion
for _ in range(1, blocks):
layers.append(block(in_planes, planes, norm_layer=norm_layer))
return layers
def _make_layer(self, block, planes, blocks, stride=1):
norm_layer = nn.BatchNorm2d
downsample = None
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = nn.Sequential(
conv1x1(self.inplanes, planes * block.expansion, stride),
norm_layer(planes * block.expansion),
)
layers = []
layers.append(
block(self.inplanes, planes, stride, downsample, self.groups,
self.base_width, self.dilation, norm_layer))
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,
norm_layer=norm_layer))
return nn.Sequential(*layers)
def _make_layer(self, block: Type[Union[BasicBlock, Bottleneck]], planes: int, blocks: int,
stride: int = 1, dilate: bool = False) -> nn.Sequential:
norm_layer = self._norm_layer
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),
norm_layer(planes * block.expansion),
)
layers = []
layers.append(block(self.inplanes, planes, stride, downsample, self.groups,
self.base_width, previous_dilation, norm_layer))
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,
norm_layer=norm_layer))
return nn.Sequential(*layers)
def _make_layer(self,
block,
cbamblock,
planes,
blocks,
withCAM,
withSAM,
stride=1,
dilate=False,
redr=16,
camflag='full',
samsize=7,
samflag='full',
samplanes=None):
norm_layer = self._norm_layer
downsample = None
previous_dilation = self.dilation
if dilate:
self.dilation *= stride
stride = 1
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = torch.nn.Sequential(
conv1x1(self.inplanes, planes * block.expansion, stride),
norm_layer(planes * block.expansion),
)
layer = []
if ((not withCAM) and (not withSAM)):
layer.append(
block(self.inplanes, planes, stride, downsample, self.groups,
self.base_width, previous_dilation, norm_layer))
else:
_block = cbamblock(self.inplanes, planes, withCAM, withSAM, stride,
downsample, self.groups, self.base_width,
previous_dilation, norm_layer, redr, camflag,
samsize, samflag, samplanes)
layer.append(_block)
self.cbamlayer.append(_block.cbamblock)
self.inplanes = planes * block.expansion
for _ in range(1, blocks):
if ((not withCAM) and (not withSAM)):
layer.append(
block(self.inplanes,
planes,
groups=self.groups,
base_width=self.base_width,
dilation=self.dilation,
norm_layer=norm_layer))
else:
_block = cbamblock(self.inplanes,
planes,
withCAM,
withSAM,
groups=self.groups,
base_width=self.base_width,
dilation=self.dilation,
norm_layer=norm_layer,
redr=redr,
camflag=camflag,
samsize=samsize,
samflag=samflag,
samplanes=samplanes)
layer.append(_block)
self.cbamlayer.append(_block.cbamblock)
return torch.nn.Sequential(*layer)
def _make_layer(block,
in_dim,
out_dim,
blocks,
stride=1,
pool=None,
pool_size=None,
norm_layer=None,
is_first=False,
is_last=False,
end_act=True,
n_blocks=None):
if n_blocks is None:
n_blocks = 1 if is_first or is_last else blocks
if stride is None:
stride = []
elif isinstance(stride, int):
stride = [stride] + [1] * (n_blocks - 1)
if isinstance(in_dim[0], int):
in_dim = [in_dim] + [out_dim] * (n_blocks - 1)
if isinstance(out_dim, int):
out_dim = [out_dim]
elif isinstance(out_dim[0], int):
out_dim = [out_dim] * n_blocks
if pool_size is None or isinstance(pool_size, int):
pool_size = [None] * (n_blocks - 1) + [pool_size]
assert len(stride) == n_blocks or is_last and len(stride) == n_blocks - 1
layers = []
if is_first:
in_size, in_dim = in_dim[0], in_dim[1:]
in_planes = in_size[0]
out_size, out_dim = out_dim[0], out_dim[1:]
out_planes = out_size[0]
s, stride = stride[0], stride[1:]
p, pool_size = pool_size[0], pool_size[1:]
layers.extend([
conv3x3(in_planes, out_planes),
get_norm_layer(norm_layer, out_size)
])
if end_act:
layers.append(nn.ReLU())
assert len(stride) <= len(in_dim) and len(stride) <= len(out_dim)
for l in range(len(stride)):
in_s, in_dim = in_dim[0], in_dim[1:]
out_s, out_dim = out_dim[0], out_dim[1:]
s, stride = stride[0], stride[1:]
downsample = None
if s != 1 or in_s[0] != out_s[0]:
downsample = nn.Sequential(
Contiguousize(),
conv1x1(in_s[0], out_s[0], s),
get_norm_layer(norm_layer, out_s),
)
layers.append(
block(in_s, out_s, s, downsample, norm_layer, end_act
or l < blocks - 1))
p, pool_size = pool_size[0], pool_size[1:]
if p is not None:
layers.append(nn.ReLU())
layers.append(get_pool_l(pool, p))
# layers.append(nn.ReLU())
assert not stride
assert not any(pool_size)
# if stride:
# in_dim = in_dim[d:]
# out_dim = out_dim[d:]
# part.remove(0)
# in_planes = out_planes * block.expansion
# for d in range(1, blocks):
# if d in part:
# layers.append(block(out_dim, out_dim, norm_layer=norm_layer,
# end_act=end_act or d < blocks - 1))
# if any(pool_size):
#
# layers.append(nn.ReLU())
# layers.append(pool_l(1))
if is_last:
in_size, in_dim = in_dim[0], in_dim[1:]
in_planes = in_size[0]
out_size, out_dim = out_dim[0], out_dim[1:]
if not isinstance(out_size, int):
assert len(out_size) == 1
out_size = out_size[0]
assert len(in_size) == 3
layers.extend([Flatten(), nn.Linear(in_planes, out_size)])
return layers
def _downsample(inplanes,outplanes,stride):
return torch.nn.Sequential(
conv1x1(inplanes, outplanes, stride),
torch.nn.BatchNorm2d(outplanes),
)
def _downsample(self, in_planes, out_planes, stride):
return nn.Sequential(conv1x1(in_planes, out_planes, stride),
nn.BatchNorm2d(out_planes))
def get_downsample(channels_in, channels_out, stride=1):
"""Standart resnet normalziation. Same as in torchvision.resnet"""
return nn.Sequential(resnet.conv1x1(channels_in, channels_out, stride),
nn.BatchNorm2d(channels_out))
def make_downsample(inplanes, planes, stride=2):
downsample = nn.Sequential(conv1x1(inplanes, planes, stride),
nn.BatchNorm2d(planes))
return downsample
def __init__(self, inplanes, planes, stride):
super(DownSample, self).__init__()
self.downsample = nn.Sequential(
resnet.conv1x1(inplanes, planes, stride),
nn.BatchNorm2d(planes),
)
