def __init__(self, block_config: list, backbone_feat_channel: list, hidden_dim: int, growth_rate: int): super(Tokenizer, self).__init__() backbone_feat_channel.reverse() # reverse so we have high-level first (lowest-spatial res) block_config.reverse() self.num_resolution = len(backbone_feat_channel) self.block_config = block_config self.growth_rate = growth_rate self.bottle_neck = _DenseBlock(block_config[0], backbone_feat_channel[0], 4, drop_rate=0.0, growth_rate=growth_rate) up = [] dense_block = [] prev_block_channels = growth_rate * block_config[0] for i in range(self.num_resolution): if i == self.num_resolution - 1: up.append(TransitionUp(prev_block_channels, hidden_dim, 4)) dense_block.append(DoubleConv(hidden_dim + 3, hidden_dim)) else: up.append(TransitionUp(prev_block_channels, prev_block_channels)) cur_channels_count = prev_block_channels + backbone_feat_channel[i + 1] dense_block.append( _DenseBlock(block_config[i + 1], cur_channels_count, 4, drop_rate=0.0, growth_rate=growth_rate)) prev_block_channels = growth_rate * block_config[i + 1] self.up = nn.ModuleList(up) self.dense_block = nn.ModuleList(dense_block)
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, in_channels, output_channel=512, **kwargs): super(DenseNet, self).__init__() self.features = nn.Sequential( nn.Conv2d(in_channels, 64, 5, padding=2, stride=2, bias=False), _DenseBlock(8, 64, 4, 8, 0), _make_transition(128, 128, 2, 0, 0.2), _DenseBlock(8, 128, 4, 8, 0), _make_transition(192, 128, (2, 1), 0, 0.2), _DenseBlock(8, 128, 4, 8, 0), nn.BatchNorm2d(192), nn.ReLU()) self.out_channels = 768
def __init__(self, in_channels): super(DenseNet, self).__init__() self.features = nn.Sequential( nn.Conv2d(in_channels=in_channels, out_channels=64, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(64, momentum=0.9), nn.ReLU(), nn.Conv2d(in_channels=64, out_channels=64, kernel_size=2, stride=2, bias=False), _DenseBlock(num_input_features=64, num_layers=8, bn_size=4, growth_rate=8, drop_rate=0), _Transition(in_channels=128, out_channels=128, pool_stride=2, pool_pad=0, dropout=0.2), _DenseBlock(num_input_features=128, num_layers=8, bn_size=4, growth_rate=8, drop_rate=0), _Transition(in_channels=192, out_channels=192, pool_stride=(2, 1), pool_pad=(0, 1), dropout=0.2), _DenseBlock(num_input_features=192, num_layers=8, bn_size=4, growth_rate=8, drop_rate=0), nn.BatchNorm2d(256, momentum=0.9), nn.ReLU(), nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, padding=0, bias=False), nn.BatchNorm2d(512, momentum=0.9), nn.ReLU(), nn.Conv2d(in_channels=512, out_channels=1024, kernel_size=2, padding=(0, 1), bias=False), nn.BatchNorm2d(1024, momentum=0.9), nn.ReLU())
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, 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, 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, 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, attn_params=None): super(DenseNet, self).__init__() # First convolution -- cf paper section 3 implementation details # all densenet have 3 dense blocks except imagenet which uses 4; imagenet config also uses different network stem if len(block_config)==4: # imagenet config 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)), ])) if attn_params is not None: # scale input dims to attn HW outputs after pooling layer attn_params['input_dims'] = attn_params['input_dims'][0] // 4, attn_params['input_dims'][1] // 4 else: # all densenet configs except imagenet described in the paper self.features = nn.Sequential(OrderedDict([ ('conv0', nn.Conv2d(3, num_init_features, kernel_size=5, stride=1, padding=2, 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=num_features // 2, attn_params=attn_params) self.features.add_module('transition%d' % (i + 1), trans) num_features = num_features // 2 # attention -- scale input dims to attn HW outputs after downsampling in transition layer if attn_params is not None: attn_params['input_dims'] = attn_params['input_dims'][0] // 2, attn_params['input_dims'][1] // 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, 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, 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, num_layers=4, in_chans=64, bn_size=4, growth_rate=32, drop_rate=0): super(DenseBlock, self).__init__() self.block = _DenseBlock(num_layers=num_layers, num_input_features=in_chans, bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
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=32, block_config=(6, 12, 24, 16), num_init_features=64, bn_size=4, drop_rate=0.1, memory_efficient=False): super(DenseNet, self).__init__() # First convolution self.features = nn.Sequential( OrderedDict([ ('conv0', nn.Conv2d(channels, num_init_features, kernel_size=7, stride=(2, 2), padding=3, bias=False)), ('norm0', nn.BatchNorm2d(num_init_features)), ('relu0', nn.ReLU(inplace=True)), ('pool0', nn.MaxPool2d(kernel_size=2, stride=(2, 1), padding=0)), ])) # 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: if i % 2 == 0: trans = Transition22(num_input_features=num_features, num_output_features=num_features // 2) elif i % 2 == 1: trans = Transition21(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))
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, 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, 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, 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): 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, growth_rate=12, block_config=(16, 16, 16), compression=0.5, num_init_features=24, bn_size=4, drop_rate=0, num_classes=10, cifar=True, groups=1): super(DenseNet, self).__init__() assert 0 < compression <= 1, 'compression of densenet should be between 0 and 1' self.avgpool_size = 8 if cifar else 7 # First convolution if cifar: self.features = nn.Sequential( OrderedDict([ ('conv0', nn.Conv2d(3, num_init_features, kernel_size=3, stride=1, padding=1, bias=False, groups=groups)), ])) 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=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: num_compressed = int(num_features * compression) trans = _Transition(num_input_features=num_features, num_output_features=num_compressed) self.features.add_module('transition%d' % (i + 1), trans) num_features = num_compressed # Final batch norm self.features.add_module('norm_final', 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(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, 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()