def _make_layer(block, out_channels, blocks, stride=1, in_channels=1, bn=True, convmap_channels=None): # first block should contain resampling layer if resample1 = None if stride != 1 or in_channels != out_channels * block.expansion: resample1 = nn.Sequential( models.resnet.conv1x1(in_channels, out_channels * block.expansion, stride), MaybeModule(bn, nn.BatchNorm2d(out_channels * block.expansion))) layers = [block(in_channels, out_channels, stride, resample1, bn=bn)] # inbetween, "normal" blocks are inserted (no resampling needed) in_channels = out_channels * block_class.expansion for _ in range(1, blocks - 1): layers.append(block(in_channels, out_channels, bn=bn)) # last block in layer, takes into account how many channels we want in the output resampleN = None if convmap_channels and convmap_channels != out_channels: out_channels = convmap_channels resampleN = nn.Sequential( models.resnet.conv1x1(in_channels, out_channels), MaybeModule(bn, nn.BatchNorm2d(out_channels))) layers.append( block(in_channels, out_channels, 1, resampleN, bn=bn, expand=False)) return nn.Sequential(*layers)
def from_spec(cls, spec): features = load_with_spec(spec['conv'], module_by_kind) hidden = load_with_spec(spec['hidden'], module_by_kind) output = load_with_spec(spec['output'], module_by_kind) use_fc_from_conv = spec.get('use_fc_from_conv', False) # conv1x1_conv2hid = nn.Conv1d(spec['conv']['convmap_channels'], spec['hidden']['feature_dim'], (1, 1)) if use_fc_from_conv: conv_adapter = ConvAdapter(spec['conv']['convmap_channels'], spec['hidden']['feature_dim'], bn=spec['conv']['bn']) else: conv_adapter = None fc_from_conv = MaybeModule(maybe=use_fc_from_conv, layer=conv_adapter) # conv1x1_hid2out = nn.Conv1d(spec['hidden']['feature_dim'], spec['output']['hidden_dim'], 1) use_fc_from_hidden = spec.get('use_fc_from_hidden', False) if use_fc_from_hidden: transformer_adapter = TransformerAdapter( spec['hidden']['feature_dim'], spec['output']['in_features'], bn=False) else: transformer_adapter = None fc_from_hidden = MaybeModule(maybe=use_fc_from_hidden, layer=transformer_adapter) return cls(features, hidden, output, fc_from_conv, fc_from_hidden)
def __init__(self, inplanes, planes, stride=1, resample=None, bn=True, expand=True): super(BasicBlock, self).__init__(resample=resample) self.conv = nn.Sequential( models.resnet.conv3x3(inplanes, planes, stride), MaybeModule(bn, nn.BatchNorm2d(planes)), nn.LeakyReLU(inplace=True), models.resnet.conv3x3(planes, planes), MaybeModule(bn, nn.BatchNorm2d(planes)), )
def resnet_model_creator(in_channels=1, convmap_channels=128, blocks=1, conf='18', bn=True): block_class, blocks_out_channels, blocks_in_layer, stride_in_layer = { '18': resnet18, '34': resnet34, '50': resnet50, '101': resnet101, '152': resnet152, }[conf] pre_channels = 64 pre_layers = nn.Sequential( nn.Conv2d(in_channels, pre_channels, kernel_size=7, stride=2, padding=3, bias=False), MaybeModule(bn, nn.BatchNorm2d(pre_channels)), nn.LeakyReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1), ) resnet_feat = [pre_layers] def _make_layer(block, out_channels, blocks, stride=1, in_channels=1, bn=True, convmap_channels=None): # first block should contain resampling layer if resample1 = None if stride != 1 or in_channels != out_channels * block.expansion: resample1 = nn.Sequential( models.resnet.conv1x1(in_channels, out_channels * block.expansion, stride), MaybeModule(bn, nn.BatchNorm2d(out_channels * block.expansion))) layers = [block(in_channels, out_channels, stride, resample1, bn=bn)] # inbetween, "normal" blocks are inserted (no resampling needed) in_channels = out_channels * block_class.expansion for _ in range(1, blocks - 1): layers.append(block(in_channels, out_channels, bn=bn)) # last block in layer, takes into account how many channels we want in the output resampleN = None if convmap_channels and convmap_channels != out_channels: out_channels = convmap_channels resampleN = nn.Sequential( models.resnet.conv1x1(in_channels, out_channels), MaybeModule(bn, nn.BatchNorm2d(out_channels))) layers.append(block(in_channels, out_channels, 1, resampleN, bn=bn, expand=False)) return nn.Sequential(*layers) # Build the requested number of resnet blocks assert 1 <= blocks <= 4, 'number of blocks requested for ResNet model should be 1, 2, 3, or 4' in_channels = pre_channels for block_idx, out_channels, numblocks, stride in zip( range(0, blocks), blocks_out_channels, blocks_in_layer, stride_in_layer): convmap_channels_supplied = convmap_channels if block_idx == blocks - 1 else None layer = _make_layer(block_class, out_channels, numblocks, stride, in_channels=in_channels, convmap_channels=convmap_channels_supplied, bn=bn) in_channels = out_channels * block_class.expansion resnet_feat.append(layer) return nn.Sequential(*resnet_feat)
def _make_layers(cfg, batch_norm=False, in_channels=1): layers = [] for v in cfg: if v == 'M': layers += [nn.MaxPool2d(kernel_size=2, stride=2)] else: layers += [ nn.Conv2d(in_channels, v, kernel_size=3, padding=1), MaybeModule(batch_norm, nn.BatchNorm2d(v)), nn.LeakyReLU(inplace=True) ] in_channels = v return nn.Sequential(*layers)
def __init__(self, in_channels, out_channels, kernel_size, bn=True, conv_class=nn.Conv1d): super().__init__() bn_class = { nn.Conv1d: nn.BatchNorm1d, nn.Conv2d: nn.BatchNorm2d }[conv_class] modules = (conv_class(in_channels, out_channels, kernel_size), MaybeModule(bn, bn_class(out_channels)), nn.LeakyReLU(inplace=True)) self.block = nn.Sequential(*modules)
def __init__(self, in_features, out_features, normalization='batch_norm', dropout=0.): super(_BasicLinear, self).__init__() # callable functions used for creating classes normalization_modules = { 'batch_norm': nn.BatchNorm1d, 'instance_norm': nn.InstanceNorm1d, 'none': lambda num_features: MaybeModule(False, None) } self.layer = nn.Sequential(*( nn.Linear(in_features, out_features), normalization_modules[normalization](out_features), nn.LeakyReLU(inplace=True), nn.Dropout(dropout) ))