def __init__(self, config, anchors, num_cls, growth_rate=32, block_config=(6, 12, 24, 16), num_init_features=64, bn_size=4, drop_rate=0):
nn.Module.__init__(self)
# First convolution
self.layers = nn.Sequential(OrderedDict([
('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features, bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
self.layers.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
self.layers.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.layers.add_module('norm5', nn.BatchNorm2d(num_features))
self.layers.add_module('conv', nn.Conv2d(num_features, model.output_channels(len(anchors), num_cls), 1))
def __init__(self, argparse):
"""
:param argparse: hyper parameter
"""
super(PolicyValueFn, self).__init__()
self.args = argparse
self.conv = nn.Sequential(
nn.BatchNorm2d(self.args.channels),
nn.Conv2d(self.args.channels, 32, kernel_size=(1, 1)),
nn.ReLU(inplace=True))
self.dense = nn.Sequential(
_DenseBlock(num_layers=7,
num_input_features=32,
bn_size=4,
growth_rate=12,
drop_rate=self.args.drop_rate),
_Transition(num_input_features=32 + 7 * 12,
num_output_features=12),
_DenseBlock(num_layers=7,
num_input_features=12,
bn_size=2,
growth_rate=9,
drop_rate=self.args.drop_rate))
size = (self.args.size // 2)**2 * (12 + 7 * 9)
self.policyFc = nn.Linear(size, self.args.size**2)
self.valueFc = nn.Linear(size, 1)
def __init__(self, config_channels, anchors, num_cls, growth_rate=32, block_config=(6, 12, 24, 16), num_init_features=64, bn_size=4, drop_rate=0):
nn.Module.__init__(self)
# First convolution
self.features = nn.Sequential(OrderedDict([
('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features, bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
self.features.add_module('conv', nn.Conv2d(num_features, model.output_channels(len(anchors), num_cls), 1))
# init
for m in self.modules():
if isinstance(m, nn.Conv2d):
m.weight = nn.init.kaiming_normal(m.weight)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self,
out_dim=256,
in_channels=3,
fpn_finest_layer=1):
super().__init__()
self.depth = 121
self.feature_upsample = True
self.fpn_finest_layer = fpn_finest_layer
self.out_dim = out_dim
self.in_channel = in_channels
assert self.depth in [121]
if self.depth == 121:
num_init_features = 64
growth_rate = 32
block_config = (6, 12, 24)
self.in_dim = [64, 256, 512, 1024]
bn_size = 4
drop_rate = 0
# First convolution
self.conv0 = nn.Conv2d(self.in_channel, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)
self.norm0 = nn.BatchNorm2d(num_init_features)
self.relu0 = nn.ReLU(inplace=True)
self.pool0 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features,
bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate, \
memory_efficient=True)
self.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
self.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
# self.add_module('norm5', nn.BatchNorm2d(num_features))
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight.data)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
m.bias.data.zero_()
if self.feature_upsample:
for p in range(4, self.fpn_finest_layer - 1, -1):
layer = nn.Conv2d(self.in_dim[p - 1], self.out_dim, 1)
name = 'lateral%d' % p
self.add_module(name, layer)
nn.init.kaiming_uniform_(layer.weight, a=1)
nn.init.constant_(layer.bias, 0)
self.init_weights()
def __init__(self,
growth_rate=32,
block_config=(6, 6, 6),
num_init_features=64,
bn_size=4,
drop_rate=0,
num_classes=1000):
super(DenseNet, self).__init__()
self.block_config = block_config
# First convolution
self.first_conv = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(3,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
self.denseblock = []
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
self.denseblock.append(
nn.Sequential(OrderedDict([
(f'dblock{i}', block),
])))
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.denseblock[i].add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.final_bn = nn.BatchNorm2d(num_features)
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.constant_(m.bias, 0)
self.denseblock = nn.ModuleList(self.denseblock)
def __init__(self,
growth_rate=32,
block_config=(6, 12, 24, 16),
u_depth=[5, 4, 3],
num_init_features=64,
bn_size=4,
drop_rate=0,
num_classes=1000):
super(DenseNet, self).__init__()
# First convolution
self.features = OrderedDict([
('conv0',
nn.Conv2d(48,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
])
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
self.features['denseblock%d' % (i + 1)] = block
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features['transition%d' % (i + 1)] = trans
num_features = num_features // 2
fmf = FMF(num_features, num_features, u_depth[i])
self.features['fmf%d' % (i + 1)] = fmf
# Final batch norm
self.features['norm5'] = nn.BatchNorm2d(num_features)
# Linear layer
self.classifier = nn.Linear(num_features, num_classes)
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal(m.weight.data)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
m.bias.data.zero_()
# for k, v in self.features.items():
# self.__setattr__(k, v)
self.features = nn.ModuleDict(self.features)
def __init__(self, growth_rate=32, block_config=(6, 12, 24, 16),
num_init_features=64, bn_size=4, drop_rate=0, num_classes=1000,
all_in_1_reduction=False):
super(DenseNet_LOC_HM, self).__init__()
self.all_in_1_reduction = all_in_1_reduction
# First convolution
self.features = nn.Sequential(OrderedDict([
('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features,
bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
# Convolution to reduce dimesion
self.conv_reducer_1 = nn.Conv2d(1664, 64, 1)
self.con_relu_1 = nn.ReLU()
self.conv_reducer_2 = nn.Conv2d(64, 32, 1)
self.con_relu_2 = nn.ReLU()
self.conv_reducer_3 = nn.Conv2d(32, 16, 1)
self.con_relu_3 = nn.ReLU()
self.conv_reducer_4 = nn.Conv2d(16, 8, 1)
self.con_relu_4 = nn.ReLU()
self.conv_reducer_all_in_1 = nn.Conv2d(1664, 8, 1)
# Linear layer for radiographic finding
self.classifier = nn.Linear(num_features, 1)
# Linear layer for localization
self.classifier_locations = nn.Linear(2048, 7)
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.constant_(m.bias, 0)
def __init__(self,
block_config=None,
depth=100,
growth_rate=12,
reduction=0.5,
num_classes=10,
bottleneck_size=4,
avg_pool_size=8):
super(DenseNetCIFAR, self).__init__()
# Compute blocks from depth
if block_config is None:
layers = (depth - 4) // 6
block_config = (layers,) * 3
# First convolution
num_features = growth_rate * 2
self.add_module("conv", nn.Conv2d(in_channels=3,
out_channels=num_features,
kernel_size=3,
padding=1,
bias=False))
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bottleneck_size,
growth_rate=growth_rate,
drop_rate=0)
self.add_module("block{0}".format(i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
out_features = math.floor(num_features * reduction)
trans = _Transition(num_input_features=num_features,
num_output_features=out_features)
self.add_module("transition{0}".format(i + 1), trans)
num_features = out_features
# Final batch norm
self.add_module("norm", nn.BatchNorm2d(num_features))
self.add_module("relu", nn.ReLU(inplace=True))
self.add_module("avg_pool", nn.AvgPool2d(kernel_size=avg_pool_size))
# classifier layer
outputs = int(num_features * 16 / (avg_pool_size * avg_pool_size))
self.add_module("flatten", Flatten())
self.add_module("classifier", nn.Linear(outputs, num_classes))
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight.data)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
m.bias.data.zero_()
def __init__(self,
growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
transitionBlock=False,
transitionDense=True,
bn_size=4,
drop_rate=0,
num_classes=1000,
memory_efficient=False):
super(Csp_DenseNet, self).__init__()
self.growth_down_rate = 2 if transitionBlock else 1
self.features = torch.nn.Sequential(
OrderedDict([
('conv0',
torch.nn.Conv2d(3,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', torch.nn.BatchNorm2d(num_init_features)),
('relu0', torch.nn.ReLU(inplace=True)),
('pool0', torch.nn.MaxPool2d(kernel_size=3,
stride=2,
padding=1)),
]))
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _Csp_DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate,
memory_efficient=memory_efficient,
transition=transitionBlock)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features // 2 + num_layers * growth_rate // 2
if (i != len(block_config) - 1) and transitionDense:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
self.features.add_module('norm5', torch.nn.BatchNorm2d(num_features))
self.classifier = torch.nn.Linear(num_features, num_classes)
for m in self.modules():
if isinstance(m, torch.nn.Conv2d):
torch.nn.init.kaiming_normal_(m.weight)
elif isinstance(m, torch.nn.BatchNorm2d):
torch.nn.init.constant_(m.weight, 1)
torch.nn.init.constant_(m.bias, 0)
elif isinstance(m, torch.nn.Linear):
torch.nn.init.constant_(m.bias, 0)
def __init__(self,
growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
bn_size=4,
drop_rate=0,
memory_efficient=False):
super(Encoder, self).__init__()
# First convolution
self.features = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(1,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = dsn._DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate,
memory_efficient=memory_efficient)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = dsn._Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
self.num_features = num_features
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def __init__(self,
input_n_channels,
n_features=10,
n_classes=1,
num_init_features=64,
growth_rate=32,
block_config=(6, 12, 48, 32)):
super(IcebergDenseNet4, self).__init__()
bn_size = 4
drop_rate = 0
# First convolution
self.features = Sequential(
OrderedDict([
('conv0',
Conv2d(input_n_channels,
num_init_features,
kernel_size=3,
stride=2,
padding=1,
bias=False)),
('norm0', BatchNorm2d(num_init_features)),
('relu0', ReLU(inplace=True)),
('pool0', MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', BatchNorm2d(num_features))
self.features.add_module('relu5', ReLU(inplace=True))
# Linear layer
self.classifier = Sequential(AdaptiveAvgPool2d(1), Flatten(),
Linear(num_features, n_features),
ReLU(inplace=True))
self.final_classifier = Linear(n_features + 1, n_classes)
self._initialize_weights()
def __init__(self,
growth_rate: int = 32,
block_config: Tuple[int, int, int] = (12, 12, 12),
num_init_features: int = 64,
bn_size: int = 4,
drop_rate: float = 0,
num_classes: int = 10,
memory_efficient: bool = False) -> None:
super().__init__()
# First convolution
self.features = nn.Sequential(
OrderedDict([('conv0',
nn.Conv2d(3,
num_init_features,
kernel_size=3,
stride=1,
padding=1,
bias=False))]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate,
memory_efficient=memory_efficient)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
# Linear layer
self.classifier = nn.Linear(num_features, num_classes)
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.constant_(m.bias, 0)
def __init__(self,
growth_rate=32,
block_config=(6, 12, 32, 32),
num_init_features=64,
bn_size=4,
drop_rate=0,
num_classes=1000,
all_in_1_reduction=False):
super(DenseNet_MH, self).__init__()
self.all_in_1_reduction = all_in_1_reduction
# First convolution
self.features = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(3,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
# get the classifier of the densenet
self.classifier = nn.Linear(num_features, 1)
# placeholder for the gradients
self.gradients = None
def __init__(self, growth_rate=32, block_config=(6, 12, 24, 16),
num_init_features=64, bn_size=4, dropout_rate=0, num_classes=1000,
small_inputs=True):
super(DenseNet, self).__init__()
# First convolution
if small_inputs:
self.features = nn.Sequential(OrderedDict([
('conv0', nn.Conv2d(3, num_init_features, kernel_size=3,
stride=1, padding=1, bias=False)),
]))
else:
self.features = nn.Sequential(OrderedDict([
('conv0', nn.Conv2d(3, num_init_features, kernel_size=7,
stride=2, padding=3, bias=False)),
]))
self.features.add_module('norm0', nn.BatchNorm2d(num_init_features))
self.features.add_module('relu0', nn.ReLU(inplace=True))
self.features.add_module('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1,
ceil_mode=False))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features,
bn_size=bn_size, growth_rate=growth_rate,
drop_rate=dropout_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
# Linear layer
self.classifier = nn.Linear(num_features, num_classes)
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.constant_(m.bias, 0)
def __init__(self,
growth_rate=12,
block_config=(16, 16, 16),
compression=0.5,
num_init_features=24,
bn_size=4,
drop_rate=0,
avgpool_size=8,
num_classes=10):
super(DenseNet, self).__init__()
assert 0 < compression <= 1, 'compression of densenet should be between '
self.avgpool_size = avgpool_size
# First convolution
self.features = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(3,
num_init_features,
kernel_size=3,
stride=1,
padding=1,
bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=int(num_features *
compression))
self.features.add_module('transition%d' % (i + 1), trans)
num_features = int(num_features * compression)
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
# Linear layer
self.classifier = nn.Linear(num_features, num_classes)
def __init__(self,
model_path,
growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
bn_size=4,
drop_rate=0,
num_classes=1000,
**kwargs):
super(DenseNet_Alignment, self).__init__()
# First convolution
self.firstconvolution = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(3,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
self.features = nn.Sequential()
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
# Linear layer
self.classifier = nn.Linear(num_features, num_classes)
def __init__(self,
hid_size=100,
growth_rate=32,
block_config=(2, 4, 4),
num_init_features=64,
bn_size=4,
drop_rate=0.2,
num_directions=1):
super(DNet, self).__init__()
self.features = nn.Sequential(
OrderedDict([('conv0',
nn.Conv2d(hid_size * num_directions,
num_init_features, 1))]))
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
self.features.add_module('norm4', nn.BatchNorm2d(num_features))
#self.classifier = nn.Linear(num_features, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal(m.weight.data)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
m.bias.data.zero_()
def __init__(self,
branches,
growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
bn_size=4,
drop_rate=0,
num_classes=1000):
super(MTLDenseNet,
self).__init__(growth_rate, block_config, num_init_features,
bn_size, drop_rate, num_classes)
self.classifier = None
self.fcs = ListModule(self, 'fc_')
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
for num_classes in branches:
self.fcs.append(nn.Linear(num_features, num_classes))
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.constant_(m.bias, 0)
def create_densenet_features(input_n_channels,
num_init_features=64,
growth_rate=32,
block_config=(6, 12, 48, 32)):
bn_size = 4
drop_rate = 0
# First convolution
features = Sequential(
Conv2d(input_n_channels,
num_init_features,
kernel_size=3,
stride=2,
padding=1,
bias=False),
BatchNorm2d(num_init_features),
ReLU(inplace=True),
MaxPool2d(kernel_size=3, stride=2, padding=1),
)
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
features.add_module('norm5', BatchNorm2d(num_features))
features.add_module('relu5', ReLU(inplace=True))
return features, num_features
def __init__(self,
growth_rate=32,
block_config=(6, 12, 18, 12),
bn_size=4,
drop_rate=0.,
pretrained_encoder=2,
simple=False,
debug=False):
"""
bn_size = bottleneck size, the factor by which the first conv in a _DenseLayer
is larger than the second conv.
:pretrained_encoder: int in [0,1,2] designating level of pretrained layers to use.
0 is none, 1 is just first convolutions, 2 is the first dense block.
"""
super(MammogramDenseNet, self).__init__()
self.debug = debug
self.pretrained = pretrained_encoder
self.nb_dense_blocks = len(block_config)
num_classes = 1 # indicator score of whether it is malignant
include_denseblock = self.pretrained == 2
pretrained_layers = get_pretrained_layers(
include_denseblock=include_denseblock)
self.features = nn.Sequential(pretrained_layers)
if self.pretrained == 0: # Re-initialize layers; don't use pretrained weights inside
print("self.pretrained = 0. Re-initializing weights")
for m in self.features.modules():
if isinstance(m, nn.Conv2d):
old_m = deepcopy(m)
nn.init.kaiming_normal_(m.weight)
# Conv layers have no bias when in conjunction with Batchnorm
elif isinstance(m, nn.BatchNorm2d):
old_m = deepcopy(m)
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
else:
continue
print("old m is", old_m.weight)
print("new m is", m.weight)
# Display shapes for debugging
if debug:
print("pretrained_encoder = %d" % pretrained_encoder)
print(
"Output shape after the pretrained modules (batch, channels, H, W):"
)
test_input = torch.rand(1, 1, 1024, 1024)
test_output = self.features(test_input)
print(test_output.size())
del test_input
del test_output
# A counter to track what input shape our final nn.Linear layer should expect
# Just num_channels is fine, because global avg pool at end
num_features = 256 if self.pretrained == 2 else 64
# Add the rest of the architecture (Dense blocks, transition layers)
for i, num_layers in enumerate(block_config):
if simple:
block = _SimpleDenseBlock(num_layers=num_layers,
num_input_features=num_features,
growth_rate=growth_rate,
drop_rate=drop_rate)
else:
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)
# Initialize the weights of block
for m in block.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
# Conv layers have no bias when in conjunction with Batchnorm
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
block_name = 'simpledenseblock%d' % (
i + 1) if simple else 'denseblock%d' % (i + 1)
self.features.add_module(block_name, block)
num_features = num_features + num_layers * growth_rate
if debug:
print("num features after denseblock %d:" % (i + 1),
num_features)
# Add a transition layer if not the last dense block:
# Norm, 1x1 Conv (unless simple), activation, AvgPool
if i != self.nb_dense_blocks - 1:
if simple:
trans = _SimpleTransition(num_input_features=num_features)
else:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features)
transition_name = 'simpletransition%d' % (
i + 1) if simple else 'transition%d' % (i + 1)
self.features.add_module(transition_name, trans)
if debug:
print("num features after transition %d:" % (i + 1),
num_features)
if debug: print("final num features:", num_features)
# Put the classifier here separately
# will apply it manually in forward(x), after global avg pool and reshape
self.classifier = nn.Linear(num_features, num_classes)
nn.init.constant_(self.classifier.bias, 0)
if debug:
summary(self.features)
def __init__(self, features, global_features, v2=False):
super(DualDenseNetUNetRDB, self).__init__()
self.features = features
self.global_features = global_features
self.name = 'DualDenseUnetRDB'
self.v2 = v2
channels = [64, 256, 512, 1024, 1024]
self.base_channel_size = channels[0]
if not v2:
self.smooth5 = nn.Sequential(
nn.ReLU(),
nn.Conv2d(channels[4] * 2, channels[4], kernel_size=1),
nn.ReLU(),
RDB(n_channels=channels[4],
nDenselayer=3,
growthRate=channels[4] // 4))
self.smooth4 = nn.Sequential(
nn.ReLU(), nn.Conv2d(channels[3], channels[3], kernel_size=1),
nn.ReLU())
self.smooth3 = nn.Sequential(
nn.ReLU(), nn.Conv2d(channels[2], channels[2], kernel_size=1),
nn.ReLU())
self.smooth2 = nn.Sequential(
nn.ReLU(), nn.Conv2d(channels[1], channels[1], kernel_size=1),
nn.ReLU())
self.smooth1 = nn.Sequential(
nn.ReLU(), nn.Conv2d(channels[0], channels[0], kernel_size=1),
nn.ReLU())
self.up1 = RDBUp(channels[4], channels[3],
channels[3]) # 1024 + 1024, 1024
self.up2 = RDBUp(channels[3], channels[2],
channels[2]) # 1024 + 512, 512
self.up3 = RDBUp(channels[2], channels[1],
channels[1]) # 512 + 256, 256
self.up4 = RDBUp(channels[1], channels[0],
channels[0]) # 256 + 64, 64
self.last_up = UpPad()
self.conv_3x3 = nn.Conv2d(channels[0],
channels[0],
kernel_size=3,
padding=1)
else:
self.down5 = nn.Sequential(
_Transition(channels[4] * 2, channels[4]),
_DenseBlock(num_layers=16,
num_input_features=channels[4],
bn_size=4,
growth_rate=32,
drop_rate=0,
memory_efficient=False))
self.up0 = ConvUp(channels[4] + 512, channels[4], channels[4])
self.smooth4 = nn.Sequential(nn.BatchNorm2d(channels[3]),
nn.LeakyReLU())
self.smooth3 = nn.Sequential(nn.BatchNorm2d(channels[2]),
nn.LeakyReLU())
self.smooth2 = nn.Sequential(nn.BatchNorm2d(channels[1]),
nn.LeakyReLU())
self.smooth1 = nn.Sequential(nn.BatchNorm2d(channels[0]),
nn.LeakyReLU())
# up + skip, out
self.up1 = ConvUp(channels[4], channels[3],
channels[3]) # 1024 + 1024, 1024
self.up2 = ConvUp(channels[3], channels[2],
channels[2]) # 1024 + 512, 512
self.up3 = ConvUp(channels[2], channels[1],
channels[1]) # 512 + 256, 256
self.up4 = ConvUp(channels[1], channels[0],
channels[0]) # 256 + 64, 64
self.pad_to = PadToX(32)
def __init__(self, config):
'''
There is a cleaner way of implementing this. TODO clean-up
Arguments:
config: as specified in .utils.Dense_U_Net_lidar_helper
'''
super().__init__()
self.config = config
# original densenet attributes
self.growth_rate = config.model.growth_rate
self.block_config = config.model.block_config
self.num_init_features = config.model.num_init_features
self.bn_size = config.model.bn_size
self.drop_rate = config.model.drop_rate
self.memory_efficient = config.model.memory_efficient
self.num_classes = config.model.num_classes
# param assignment
self.concat_before_block_num = config.model.concat_before_block_num
self.num_layers_before_blocks = config.model.num_layers_before_blocks
self.concat_after_module_idx = self.num_layers_before_blocks - 1 + 2 * (
self.concat_before_block_num - 1)
self.stream_1_in_channels = config.model.stream_1_in_channels
self.stream_2_in_channels = config.model.stream_2_in_channels
self.network_input_channels = self.stream_1_in_channels # Allowing for rgb input or torch.cat((rgb,lidar),1) | added
if self.concat_before_block_num == 1 and self.stream_2_in_channels == 0:
self.fusion = 'no'
elif self.concat_before_block_num == 1 and self.stream_2_in_channels > 0:
self.fusion = 'early'
self.network_input_channels += self.stream_2_in_channels
elif self.concat_before_block_num > 1 and self.concat_before_block_num <= len(
self.block_config):
self.fusion = 'mid'
else:
raise AttributeError
### core structure
## Encoder | same as densenet without norm5 and classifier
# First convolution | original densenet
self.features = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(self.network_input_channels,
self.num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(self.num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock | original densenet + stack comprising layer sizes for the decoder
feature_size_stack = deque()
feature_size_stack.append(self.num_init_features +
2 * self.growth_rate)
num_features = self.num_init_features
for i, num_layers in enumerate(self.block_config):
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=self.bn_size,
growth_rate=self.growth_rate,
drop_rate=self.drop_rate,
memory_efficient=self.memory_efficient)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * self.growth_rate
feature_size_stack.append(num_features)
if i != len(self.block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
## Decoder
# U net like | ugly: should have own class for whole sequence
self.decoder = nn.Sequential()
num_in_features = feature_size_stack.pop()
for i in range(len(self.block_config)):
num_features = feature_size_stack.pop()
transp_conv_seq = nn.Sequential(
OrderedDict(
[ # denselayer like struct; reduce channels with 1x1 convs
('norm0', nn.BatchNorm2d(num_in_features)),
('relu0', nn.ReLU(inplace=True)),
('conv_reduce',
nn.Conv2d(num_in_features,
num_features,
kernel_size=1,
stride=1,
padding=0,
bias=False)),
('norm1', nn.BatchNorm2d(num_features)),
('relu1', nn.ReLU(inplace=True))
]))
self.decoder.add_module(
'Transposed_Convolution_Sequence_%d' % (i + 1),
transp_conv_seq)
self.decoder.add_module(
'Transposed_Convolution_%d' % (i + 1),
nn.ConvTranspose2d(num_features,
num_features,
3,
stride=2,
padding=1,
bias=False))
num_in_features = num_features * 2
self.decoder.add_module('Upsampling', nn.Upsample(scale_factor=2))
# final refinement: concat orig rgb & lidar before passing
self.dec_out_to_heat_maps = nn.Sequential(
OrderedDict([
('norm0',
nn.BatchNorm2d(num_features + self.stream_1_in_channels +
self.stream_2_in_channels)),
('relu0', nn.ReLU(inplace=True)),
('refine0',
nn.Conv2d(num_features + self.stream_1_in_channels +
self.stream_2_in_channels,
num_features // 2,
3,
stride=1,
padding=1,
bias=False)),
('norm1', nn.BatchNorm2d(num_features // 2)),
('relu1', nn.ReLU(inplace=True)),
('refine1',
nn.Conv2d(num_features // 2,
self.num_classes,
5,
stride=1,
padding=2,
bias=False))
]))
### additional structure depending on fusion mechanism
if self.fusion == 'no':
# i.e. one stream only
pass
elif self.fusion == 'early':
# i.e. concat rgb and lidar before network
pass
elif self.fusion == 'mid':
# add all the same processing for the lidar data as for rgb data
# add concat layer
'''
# weirdly gives slower iteration times
# Stream_2 mirrors Stream_1 up to concat level
self.stream_2_features = copy.deepcopy(self.features[:self.concat_after_module_idx+1])
self.stream_2_features.conv0 = nn.Conv2d(self.stream_2_in_channels,
self.num_init_features, kernel_size=7, stride=2, padding=3, bias=False)
'''
# First convolution | original densenet | for lidar block
self.stream_2_features = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(self.stream_2_in_channels,
self.num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(self.num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2,
padding=1)),
]))
# Each denseblock | original densenet + break before concat layer
num_features = self.num_init_features
for i, num_layers in enumerate(self.block_config):
if i == self.concat_before_block_num - 1:
break
block = _DenseBlock(num_layers=num_layers,
num_input_features=num_features,
bn_size=self.bn_size,
growth_rate=self.growth_rate,
drop_rate=self.drop_rate,
memory_efficient=self.memory_efficient)
self.stream_2_features.add_module('denseblock%d' % (i + 1),
block)
num_features = num_features + num_layers * self.growth_rate
if i != len(self.block_config) - 1:
trans = _Transition(num_input_features=num_features,
num_output_features=num_features // 2)
self.stream_2_features.add_module('transition%d' % (i + 1),
trans)
num_features = num_features // 2
# concat layer | rgb + lidar | 1x1 conv
num_features = self.features[self.concat_after_module_idx +
1].denselayer1.norm1.num_features
self.concat_module = nn.Sequential(
OrderedDict([('norm', nn.BatchNorm2d(num_features * 2)),
('relu', nn.ReLU(inplace=True)),
('conv',
nn.Conv2d(num_features * 2,
num_features,
kernel_size=1,
stride=1,
padding=0,
bias=False))]))
else:
raise AttributeError
# Official init from torch repo
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.constant_(m.bias, 0)
# get number of parameters of model
self.num_params = sum(p.numel() for p in self.parameters())
def __init__(
self,
growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
bn_size=4,
drop_rate=0,
memory_efficient=False,
outputs=[],
url=None,
):
super(DenseNet, self).__init__()
self.url = url
self.outputs = outputs
self.block_config = block_config
# First convolution
self.conv1 = nn.Sequential(
OrderedDict([
(
"conv",
nn.Conv2d(
3,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False,
),
),
("norm", nn.BatchNorm2d(num_init_features)),
("relu", nn.ReLU(inplace=True)),
("pool", nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = densenet._DenseBlock(
num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate,
memory_efficient=memory_efficient,
)
self.add_module("denseblock%d" % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = densenet._Transition(
num_input_features=num_features,
num_output_features=num_features // 2,
)
self.add_module("transition%d" % (i + 1), trans)
num_features = num_features // 2
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.constant_(m.bias, 0)
def __init__(
self,
img_channels,
out_channels,
growth_rate=16,
block_config=(2, 6, 4, 12, 8),
num_init_features=8,
bn_size=4,
drop_rate=0.0,
):
super(DenseYOLO, self).__init__()
self.features = nn.Sequential(
OrderedDict(
[
(
"conv0",
nn.Conv2d(
in_channels=img_channels,
out_channels=num_init_features,
kernel_size=5,
padding=2,
bias=False,
),
),
("norm0", nn.BatchNorm2d(num_features=num_init_features)),
("relu0", nn.ReLU(inplace=True)),
("pool0", nn.MaxPool2d(kernel_size=2, stride=2)),
]
)
)
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(
num_layers=num_layers,
num_input_features=num_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate,
)
self.features.add_module("denseblock%d" % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(
num_input_features=num_features,
num_output_features=num_features // 2,
)
self.features.add_module("transition%d" % (i + 1), trans)
num_features = num_features // 2
self.features.add_module("norm1", nn.BatchNorm2d(num_features))
self.features.add_module(
"conv1",
nn.Conv2d(
in_channels=num_features,
out_channels=out_channels,
kernel_size=3,
stride=3,
bias=False,
),
)
# initialization
p = 1.0 / 77.0 # prior for output assumes 1 box per grid of size 11x7
b = -1.0 * np.log10((1.0 - p) / p) # bias for output layer based on focal loss paper
for name, module in self.named_modules():
if isinstance(module, nn.Conv2d):
nn.init.kaiming_normal_(module.weight, nonlinearity="relu")
elif isinstance(module, nn.BatchNorm2d):
nn.init.constant_(module.weight, 1)
if name == "features.norm1":
nn.init.constant_(module.bias, b)
else:
nn.init.constant_(module.bias, 0)
def __init__(self,
model_path,
growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
bn_size=4,
drop_rate=0,
num_classes=1000,
**kwargs):
super(MyDenseNet_stn, self).__init__()
#Branch1 First convolution
self.firstconvolution = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(3,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Branch1 denseblock 1
DBnum_features = num_init_features
TRnum_features = DBnum_features + block_config[0] * growth_rate
self.block1 = nn.Sequential(
OrderedDict([('denseblock1',
_DenseBlock(num_layers=block_config[0],
num_input_features=DBnum_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)),
('transition1',
_Transition(num_input_features=TRnum_features,
num_output_features=TRnum_features // 2))
]))
#Branch1 denseblock 2
DBnum_features = TRnum_features // 2
TRnum_features = DBnum_features + block_config[1] * growth_rate
self.block2 = nn.Sequential(
OrderedDict([('denseblock2',
_DenseBlock(num_layers=block_config[1],
num_input_features=DBnum_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)),
('transition2',
_Transition(num_input_features=TRnum_features,
num_output_features=TRnum_features // 2))
]))
#Branch1 denseblock 3
DBnum_features = TRnum_features // 2
TRnum_features = DBnum_features + block_config[2] * growth_rate
self.highnum_fea = DBnum_features
self.trannum_fea = TRnum_features
self.block3 = nn.Sequential(
OrderedDict([('denseblock3',
_DenseBlock(num_layers=block_config[2],
num_input_features=DBnum_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)),
('transition3',
_Transition(num_input_features=TRnum_features,
num_output_features=TRnum_features // 2))
]))
#Branch1 denseblock 4
DBnum_features = TRnum_features // 2
TRnum_features = DBnum_features + block_config[3] * growth_rate
self.block4 = nn.Sequential(
OrderedDict([('denseblock4',
_DenseBlock(num_layers=block_config[3],
num_input_features=DBnum_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate))]))
#Branch1 Final batch norm
self.norm5 = nn.BatchNorm2d(TRnum_features)
#Branch1 Linear layer
self.classifier = nn.Linear(TRnum_features, num_classes)
#Spatical transformer Localization network
self.localization = nn.Sequential(
OrderedDict([
('denseblock3',
_DenseBlock(num_layers=24,
num_input_features=self.highnum_fea,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)),
('transition3',
_Transition(num_input_features=self.trannum_fea,
num_output_features=self.trannum_fea // 2))
]))
self.downsample = nn.Sequential(
OrderedDict([('bn', nn.BatchNorm2d(512)),
('relu', nn.ReLU(inplace=True)),
('conv',
nn.Conv2d(512,
128,
kernel_size=1,
stride=1,
padding=0,
bias=True))]))
#Regressor
self.fc_loc = nn.Sequential(nn.Linear(128 * 8 * 8, 128 * 8),
nn.ReLU(True), nn.Linear(1024, 128),
nn.ReLU(True), nn.Linear(128, 32),
nn.ReLU(True), nn.Linear(32, 3 * 2))
self.fc_loc[6].weight.data.fill_(0)
self.fc_loc[6].bias.data = torch.FloatTensor([1, 0, 0, 0, 1, 0])
alignmodel = DenseNet_Alignment()
self.alignbase = alignmodel.features
self.alignclassifier = nn.Linear(TRnum_features, num_classes)
self.load_param()
def __init__(self):
super(DenseNetCustomTrunc, self).__init__()
name = cfg.MODEL.BACKBONE.CONV_BODY
self.depth = int(name.split('-')[1])
self.feature_upsample = cfg.MODEL.BACKBONE.FEATURE_UPSAMPLE
assert self.depth in [121]
if self.depth == 121:
num_init_features = 64
growth_rate = 32
block_config = (6, 12, 24)
self.in_dim = [64, 256, 512, 1024]
bn_size = 4
drop_rate = 0
# First convolution
self.conv0 = nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)
self.norm0 = nn.BatchNorm2d(num_init_features)
self.relu0 = nn.ReLU(inplace=True)
self.pool0 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features,
bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
self.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
self.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
cfg.runtime_info.backbone_ft_dim = self.in_dim[-1]
# Final batch norm
# self.add_module('norm5', nn.BatchNorm2d(num_features))
# Official init from torch repo.
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight.data)
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
m.bias.data.zero_()
if self.feature_upsample:
self.out_dim = cfg.MODEL.BACKBONE.OUT_CHANNELS
self.fpn_finest_layer = cfg.MODEL.BACKBONE.FEATURE_UPSAMPLE_LEVEL-1
for p in range(4, self.fpn_finest_layer - 1, -1):
layer = nn.Conv2d(self.in_dim[p - 1], self.out_dim, 1)
name = 'lateral%d' % p
self.add_module(name, layer)
nn.init.kaiming_uniform_(layer.weight, a=1)
nn.init.constant_(layer.bias, 0)
cfg.runtime_info.backbone_ft_dim = self.out_dim
self.indim_ilf = [64, 128, 256]
self.num_image = cfg.INPUT.NUM_IMAGES_3DCE
self.feature_fusion_level_list = cfg.MODEL.BACKBONE.FEATURE_FUSION_LEVELS
for p in range(len(self.feature_fusion_level_list)):
if self.feature_fusion_level_list[p]:
layer = nn.Conv2d(self.num_image * self.indim_ilf[p], self.indim_ilf[p], 1)
self.add_module('conv_ilf%d'%p, layer)
def __init__(self, growth_rate=32, block_config=(6, 12, 24, 16),
num_init_features=64, bn_size=4, drop_rate=0, num_classes=1000,
bp_position=False, hidden_layers_att=1, Heads=4, dq=16, dv=16, kernel_att=3, stride_att=1,
non_linearity_att='softmax', self_att=False):
super(DenseNet_att_QKV_HM, self).__init__()
self.bp_position = bp_position
self.hidden_layers_att = hidden_layers_att
self.Nh = Heads
self.dq = dq
self.dv = dv
self.kernel_att = kernel_att
self.stride_att = stride_att
self.padding_att = (self.kernel_att - 1) // 2
self.non_linearity_att = non_linearity_att
self.self_att = self_att
# First convolution
self.features = nn.Sequential(OrderedDict([
('conv0', nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features,
bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
# Convolution to reduce dimesion
if self.self_att is True:
self.conv_reducer_1 = nn.Conv2d(1664, 64, 1)
else:
self.conv_reducer_1 = nn.Conv2d(self.dq, 64, 1)
self.con_relu_1 = nn.ReLU()
self.conv_reducer_2 = nn.Conv2d(64, 32, 1)
self.con_relu_2 = nn.ReLU()
self.conv_reducer_3 = nn.Conv2d(32, 16, 1)
self.con_relu_3 = nn.ReLU()
self.conv_reducer_4 = nn.Conv2d(16, 8, 1)
self.con_relu_4 = nn.ReLU()
#Guide attention
self.conv_embedding = AttentionNet(1664, self.dq, self.hidden_layers_att, self.kernel_att, self.stride_att)
if self.self_att is True:
self.conv_get_K = nn.Conv2d(1664, self.dq, self.kernel_att, self.stride_att, self.padding_att)
else:
self.conv_get_K = nn.Conv2d(self.dq, self.dq, self.kernel_att, self.stride_att, self.padding_att)
self.conv_get_QV = nn.Conv2d(1664, self.dq + self.dv, self.kernel_att, self.stride_att, self.padding_att)
self.conv_reducer_att_output = nn.Conv2d(int((self.dv)), int(4*self.Nh), 1)
self.softmax_att = nn.Softmax()
self.sigmoid_att = nn.Sigmoid()
# Linear layer for localization
self.classifier_locations = nn.Linear(2048, 7)
# Official init from torch repo.
# Linear layer for radiographic finding
self.classifier = nn.Linear(4 * self.Nh * 16 * 16, 1)
#self.classifier = nn.Linear(832, 1)
if self.non_linearity_att == 'sigmoid':
self.bn = torch.nn.BatchNorm2d(self.Nh)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.constant_(m.bias, 0)
def __init__(self,
model_path,
growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
bn_size=4,
drop_rate=0,
num_classes=1000,
gh=False,
ah=False,
**kwargs):
super(MyDenseNet_stn_local, self).__init__()
self.gh = gh
self.ah = ah
#Branch1 First convolution
self.firstconvolution = nn.Sequential(
OrderedDict([
('conv0',
nn.Conv2d(3,
num_init_features,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
# Branch1 denseblock 1
DBnum_features = num_init_features
TRnum_features = DBnum_features + block_config[0] * growth_rate
self.block1 = nn.Sequential(
OrderedDict([('denseblock1',
_DenseBlock(num_layers=block_config[0],
num_input_features=DBnum_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)),
('transition1',
_Transition(num_input_features=TRnum_features,
num_output_features=TRnum_features // 2))
]))
#Branch1 denseblock 2
DBnum_features = TRnum_features // 2
TRnum_features = DBnum_features + block_config[1] * growth_rate
self.block2 = nn.Sequential(
OrderedDict([('denseblock2',
_DenseBlock(num_layers=block_config[1],
num_input_features=DBnum_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)),
('transition2',
_Transition(num_input_features=TRnum_features,
num_output_features=TRnum_features // 2))
]))
#Branch1 denseblock 3
DBnum_features = TRnum_features // 2
TRnum_features = DBnum_features + block_config[2] * growth_rate
self.highnum_fea = DBnum_features
self.trannum_fea = TRnum_features
self.block3 = nn.Sequential(
OrderedDict([('denseblock3',
_DenseBlock(num_layers=block_config[2],
num_input_features=DBnum_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)),
('transition3',
_Transition(num_input_features=TRnum_features,
num_output_features=TRnum_features // 2))
]))
#Branch1 denseblock 4
DBnum_features = TRnum_features // 2
TRnum_features = DBnum_features + block_config[3] * growth_rate
self.block4 = nn.Sequential(
OrderedDict([('denseblock4',
_DenseBlock(num_layers=block_config[3],
num_input_features=DBnum_features,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate))]))
#Branch1 Final batch norm
self.norm5 = nn.BatchNorm2d(TRnum_features)
#Branch1 Linear layer
self.classifier = nn.Linear(TRnum_features, num_classes)
if self.gh:
# =====================append conv for Horizontal======================= #
self.localgh_conv = nn.Conv2d(1024,
256,
kernel_size=1,
padding=0,
bias=False)
init.kaiming_normal(self.localgh_conv.weight, mode='fan_out')
self.ghfeat_bn2d = nn.BatchNorm2d(256)
init.constant(self.ghfeat_bn2d.weight, 1)
init.constant(self.ghfeat_bn2d.bias, 0)
##------------------------------stripe----------------------------------------##
self.ghinstance0 = nn.Linear(256, self.num_classes)
init.normal(self.ghinstance0.weight, std=0.001)
init.constant(self.ghinstance0.bias, 0)
##------------------------------stripe----------------------------------------##
##------------------------------stripe----------------------------------------##
self.ghinstance1 = nn.Linear(256, self.num_classes)
init.normal(self.ghinstance1.weight, std=0.001)
init.constant(self.ghinstance1.bias, 0)
##------------------------------stripe----------------------------------------##
##------------------------------stripe----------------------------------------##
self.ghinstance2 = nn.Linear(256, self.num_classes)
init.normal(self.ghinstance2.weight, std=0.001)
init.constant(self.ghinstance2.bias, 0)
##------------------------------stripe----------------------------------------##
##------------------------------stripe----------------------------------------##
self.ghinstance3 = nn.Linear(256, self.num_classes)
init.normal(self.ghinstance3.weight, std=0.001)
init.constant(self.ghinstance3.bias, 0)
##------------------------------stripe----------------------------------------##
self.ghdrop = nn.Dropout(0.5)
#Spatical transformer Localization network
self.localization = nn.Sequential(
OrderedDict([
('denseblock3',
_DenseBlock(num_layers=24,
num_input_features=self.highnum_fea,
bn_size=bn_size,
growth_rate=growth_rate,
drop_rate=drop_rate)),
('transition3',
_Transition(num_input_features=self.trannum_fea,
num_output_features=self.trannum_fea // 2))
]))
self.downsample = nn.Sequential(
OrderedDict([('bn', nn.BatchNorm2d(512)),
('relu', nn.ReLU(inplace=True)),
('conv',
nn.Conv2d(512,
128,
kernel_size=1,
stride=1,
padding=0,
bias=True))]))
#Regressor
self.fc_loc = nn.Sequential(nn.Linear(128 * 8 * 8, 128 * 8),
nn.ReLU(True), nn.Linear(1024, 128),
nn.ReLU(True), nn.Linear(128, 32),
nn.ReLU(True), nn.Linear(32, 3 * 2))
self.fc_loc[6].weight.data.fill_(0)
self.fc_loc[6].bias.data = torch.FloatTensor([1, 0, 0, 0, 1, 0])
alignmodel = DenseNet_Alignment()
self.alignbase = alignmodel.features
self.alignclassifier = nn.Linear(TRnum_features, num_classes)
if self.ah:
# =====================append conv for Horizontal======================= #
self.localah_conv = nn.Conv2d(1024,
256,
kernel_size=1,
padding=0,
bias=False)
init.kaiming_normal(self.localah_conv.weight, mode='fan_out')
self.ahfeat_bn2d = nn.BatchNorm2d(256)
init.constant(self.ahfeat_bn2d.weight, 1)
init.constant(self.ahfeat_bn2d.bias, 0)
##------------------------------stripe----------------------------------------##
self.ahinstance0 = nn.Linear(256, self.num_classes)
init.normal(self.ahinstance0.weight, std=0.001)
init.constant(self.ahinstance0.bias, 0)
##------------------------------stripe----------------------------------------##
##------------------------------stripe----------------------------------------##
self.ahinstance1 = nn.Linear(256, self.num_classes)
init.normal(self.ahinstance1.weight, std=0.001)
init.constant(self.ahinstance1.bias, 0)
##------------------------------stripe----------------------------------------##
##------------------------------stripe----------------------------------------##
self.ahinstance2 = nn.Linear(256, self.num_classes)
init.normal(self.ahinstance2.weight, std=0.001)
init.constant(self.ahinstance2.bias, 0)
##------------------------------stripe----------------------------------------##
##------------------------------stripe----------------------------------------##
self.ahinstance3 = nn.Linear(256, self.num_classes)
init.normal(self.ahinstance3.weight, std=0.001)
init.constant(self.ahinstance3.bias, 0)
##------------------------------stripe----------------------------------------##
self.ahdrop = nn.Dropout(0.5)
self.load_param()
def __init__(self, num_input_features=16, num_output_features=32):
super(TransitionBlock, self).__init__()
self.block = _Transition(num_input_features=num_input_features,
num_output_features=num_output_features)
