def __init__(self, num_input_features, growth_rate, bn_size, drop_rate):
super(_DenseLayer, self).__init__()
self.layers = []
self.add_module('1',BatchNorm2d(num_input_features))
self.add_module('2',ReLU(inplace=False))
self.add_module('3',Conv2d(num_input_features, bn_size * growth_rate, kernel_size=1, stride=1, bias=False)) # L*k -> 4*k
self.add_module('4',BatchNorm2d(bn_size * growth_rate))
self.add_module('5',ReLU(inplace=False))
self.add_module('6',Conv2d(bn_size * growth_rate, growth_rate, kernel_size=3, stride=1, padding=1, bias=False)) # 4*k -> k
self.drop_rate = drop_rate
self.growth_rate = growth_rate
def conv1x1(in_planes, out_planes, stride=1):
"""1x1 convolution"""
return Conv2d(in_planes,
out_planes,
kernel_size=1,
stride=stride,
bias=False)
def __init__(self, block, layers, num_classes=2, zero_init_residual=False, input_depth=None):
super(ResNet, self).__init__()
self.inplanes = 64
self.conv1 = Conv2d(input_depth, 64, kernel_size=7, stride=2, padding=3,
bias=False)
self.bn1 = BatchNorm2d(64)
self.relu = ReLU(inplace=True)
self.maxpool = 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)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
self.avgpool = AdaptiveAvgPool2d((1, 1))
self.fc = Linear(512 * block.expansion, num_classes, whichScore = args.whichScore,lastLayer=True)
for m in self.modules():
if isinstance(m, Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
elif isinstance(m, BatchNorm2d):
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, num_input_features, num_output_features):
super(_Transition, self).__init__()
self.layers = []
self.add_module('1',BatchNorm2d(num_input_features))
self.add_module('2',ReLU(inplace=False))
self.add_module('3',Conv2d(num_input_features, num_output_features, kernel_size=1, stride=1, bias=False))
self.add_module('4',AvgPool2d(kernel_size=2, stride=2))
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):
super(DenseNet, self).__init__()
# First convolution
self.layers = []
self.layers.append(Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False))
self.layers.append(BatchNorm2d(num_init_features))
self.layers.append(ReLU(inplace=False))
self.layers.append(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 += 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.append(trans)
num_features = num_features // 2
# Final batch norm
self.layers.append(BatchNorm2d(num_features))
# Linear layer
self.layers.append(ReLU(inplace=False))
self.layers.append(AdaptiveAvgPool2d((1, 1)))
self.layers.append(Linear(num_features, num_classes, whichScore = args.whichScore,lastLayer=True))
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
return Conv2d(in_planes,
out_planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
def make_layers(self, cfg, batch_norm = args.vgg_bn):
layers = []
in_channels = 3
for v in cfg:
if v == 'M':
layers += [MaxPool2d(kernel_size=2, stride=2)]
else:
conv2d = Conv2d(in_channels, v, kernel_size=3, padding=1)
if batch_norm:
layers += [conv2d, BatchNorm2d(v), ReLU()]
else:
layers += [conv2d, ReLU()]
in_channels = v
return layers
def forward(self):
return Sequential(
Conv2d(1, 5, 3), ReLU(), Conv2d(5, 5, 3), ReLU(),
Linear(24 * 24 * 5, 10, lastLayer=True,
whichScore=args.whichScore))