def __init__(self): super(Net, self).__init__() self.cnn_layers = Sequential() input_channels = configuration.input_channels width = configuration.image_width height = configuration.image_height i = 1 for k, f, a, s, p, mf, ms, mp in zip( configuration.no_conv_filters, configuration.conv_filters, configuration.activation_list, configuration.conv_strides, configuration.conv_padding, configuration.maxpool_filters, configuration.maxpool_strides, configuration.maxpool_padding): self.cnn_layers.add_module("conv_2d_{}".format(i), Conv2d(input_channels, k, kernel_size=f, stride=s, padding=p)) self.cnn_layers.add_module("dropout{}".format(i), Dropout(configuration.cnn_dropout)) width = (width - f + 2 * p) / s + 1 height = (height - f + 2 * p) / s + 1 input_channels = k self.cnn_layers.add_module("activation_{}".format(i), get_activation_from_name(a)) if configuration.batch_norm: self.cnn_layers.add_module("batch_norm{}".format(i), BatchNorm2d(input_channels)) self.cnn_layers.add_module("max_pool_{}".format(i), MaxPool2d(kernel_size=mf, stride=ms, padding=mp)) width = int((width - mf + 2 * mp) / ms + 1) height =int((height - mf + 2 * mp) / ms + 1) i += 1 self.linear_layers = Sequential() self.linear_layers.add_module("flatten",Flatten()) self.linear_layers.add_module("linear_{}".format(i),Linear(input_channels * width * height, configuration.linear)) self.linear_layers.add_module("dropout_{}".format(i),Dropout(configuration.fcn_dropout)) self.linear_layers.add_module("activation_{}".format(i),get_activation_from_name(configuration.relu)) if configuration.batch_norm: self.linear_layers.add_module("batch_norm{}".format(i),BatchNorm1d(configuration.linear)) self.linear_layers.add_module("output_{}".format(i),Linear(configuration.linear, configuration.output_classes))
def __init__(self, depth, input_size, output_size, dropout=0.0, batch_norm=True): super().__init__() non_lin = ReLU() assert dropout == 0, "Dropout not allowed for ResNet" assert batch_norm # Configure ResNet # number of layers per block if (depth - 2) % 6 != 0: raise ValueError( "Only ResNet-X with X=6N-2 allowed where N natural number.") layers = (depth - 2) // 6 # number of filters for each block filters = [16, 32, 64] # Subsampling at first layer in each block strides = [1, 2, 2] # Build ResNet self.conv1 = conv3x3(int(input_size[0]), filters[0]) self.inplanes = filters[0] self.bn1 = BatchNorm2d(filters[0]) self.non_lin1 = non_lin # Each layer makes the input smaller using stride, then adds `layers` layers of two layers each with a skip self.layer1 = self._make_layer(filters[0], layers, strides[0], non_lin) self.layer2 = self._make_layer(filters[1], layers, strides[1], non_lin) self.layer3 = self._make_layer(filters[2], layers, strides[2], non_lin) # Average each filter self.avgpool = AvgPool2d( int(input_size[1]) // reduce(operator.mul, strides, 1)) self.linear_out = Linear(filters[-1], output_size) self.kind = depth self.non_linearity = non_lin.__class__ self.batch_norm = batch_norm
def __init__(self, in_channel, depth, stride): super(bottleneck_IR, self).__init__() self.stride = stride if stride == 2: self.shortcut_layer = Sequential(Conv2d(in_channel, depth, (1, 1), stride ,bias=False), BatchNorm2d(depth,eps=2e-5,momentum=0.9)) self.res_layer = Sequential( BatchNorm2d(in_channel,eps=2e-5,momentum=0.9), Conv2d(in_channel, depth, (3, 3), (1, 1), 1 ,bias=False),BatchNorm2d(depth,eps=2e-5,momentum=0.9), PReLU(depth),Conv2d(depth, depth, (3, 3), stride, 1 ,bias=False), BatchNorm2d(depth,eps=2e-5,momentum=0.9)) else: self.res_layer = Sequential( BatchNorm2d(in_channel,eps=2e-5,momentum=0.9), Conv2d(in_channel, depth, (3, 3), (1, 1), 1 ,bias=False),BatchNorm2d(depth,eps=2e-5,momentum=0.9), PReLU(depth), Conv2d(depth, depth, (3, 3), stride, 1 ,bias=False), BatchNorm2d(depth,eps=2e-5,momentum=0.9))
def __init__(self): super(Net1, self).__init__() self.features = nn.Sequential( DSC(5, 64, 3, 2, 1), BatchNorm2d(64), ReLU(inplace=True), DSC(64, 192, 3, 2, 1), BatchNorm2d(192), ReLU(inplace=True), DSC(192, 384, 3, 1, 1), BatchNorm2d(384), ReLU(inplace=True), MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False), DSC(384, 512, 3, 1, 1), BatchNorm2d(512), ReLU(inplace=True), MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False), DSC(512, 512, 3, 1, 1), BatchNorm2d(512), ReLU(inplace=True), DSC(512, 1024, 3, 1, 1), BatchNorm2d(1024), ReLU(inplace=True), MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False), DSC(1024, 1024, 3, 1, 1), BatchNorm2d(1024), ReLU(inplace=True), DSC(1024, 512, 3, 1, 1), BatchNorm2d(512), ReLU(inplace=True), DSC(512, 256, 3, 1, 1), BatchNorm2d(256), ReLU(inplace=True), CBAM(256)) self.avgpool = AdaptiveAvgPool2d(output_size=(6, 6)) self.classifier = nn.Sequential( Dropout(p=0.5), Linear(in_features=9216, out_features=2048, bias=True), ReLU(inplace=True), Dropout(p=0.5), Linear(in_features=2048, out_features=1024, bias=True), ReLU(inplace=True), Dropout(p=0.5), Linear(in_features=1024, out_features=3, bias=True))
def __init__(self, depth, widen_factor, dropout_rate, num_classes, beta=1.0, base=16, name=None): super(Wide_ResNet, self).__init__() self.in_planes, self.num_classes = base, num_classes self.beta = beta assert ((depth - 4) % 6 == 0), 'Wide-resnet depth should be 6n+4' n = (depth - 4) / 6 k = widen_factor print('| Wide-Resnet %dx%d' % (depth, k)) nStages = [base, base * k, base * k * 2, base * k * 4] self.conv1 = conv3x3(3, nStages[0]) self.layer1 = self._wide_layer(wide_basic, nStages[1], n, dropout_rate, stride=1) self.layer2 = self._wide_layer(wide_basic, nStages[2], n, dropout_rate, stride=2) self.layer3 = self._wide_layer(wide_basic, nStages[3], n, dropout_rate, stride=2) self.bn1 = BatchNorm2d(nStages[3]) self.linear = nn.Linear(nStages[3], num_classes, bias=True) self.name = name
def __init__(self, scale_factor): upsample_block_num = int(math.log(scale_factor, 2)) super(Generator, self).__init__() self.block1 = Sequential( Conv2d(3, 64, kernel_size=(9, 9), padding=(4, 4)), PReLU()) self.block2 = ResidualBlock(64) self.block3 = ResidualBlock(64) self.block4 = ResidualBlock(64) self.block5 = ResidualBlock(64) self.block6 = ResidualBlock(64) self.block7 = Sequential( Conv2d(64, 64, kernel_size=(3, 3), padding=(1, 1)), BatchNorm2d(64)) # up sampling block8 = [UpSampleBlock(64, 2) for _ in range(upsample_block_num)] block8.append(Conv2d(64, 3, kernel_size=(9, 9), padding=(4, 4))) self.block8 = Sequential(*block8)
def __init__(self, K_size=2, stride_size=1, padding_size=0, hights=5, widths=5, outs=5): super(Net, self).__init__() self.K_h = K_size[0] if isinstance(K_size, tuple) else K_size self.K_w = K_size[1] if isinstance(K_size, tuple) else K_size self.Stride_h = stride_size[0] if isinstance(stride_size, tuple) else stride_size self.Stride_w = stride_size[1] if isinstance(stride_size, tuple) else stride_size self.Padding_h = padding_size[0] if isinstance(padding_size, tuple) else padding_size self.Padding_w = padding_size[1] if isinstance(padding_size, tuple) else padding_size self.H = hights self.W = widths self.out_size = outs self.cnn_output_h = int((self.H + 2 * self.Padding_h - (self.K_h - 1) - 1) / self.Stride_h + 1) self.cnn_output_w = int((self.W + 2 * self.Padding_w - (self.K_w - 1) - 1) / self.Stride_w + 1) self.cnn_layers = Sequential( # Defining a 2D convolution layer Conv2d(1, 1, kernel_size=(self.K_h, self.K_w), stride=(self.Stride_h, self.Stride_w), padding=(self.Padding_h, self.Padding_w)), BatchNorm2d(1), ReLU(inplace=True), MaxPool2d(kernel_size=(1, self.cnn_output_w), stride=(1, self.cnn_output_w))) self.linear_layers = Sequential( Linear(self.cnn_output_h, int(self.out_size)))
def __init__( self, in_channels: int, out_channels: int, kernel_size: int, stride: int, padding: int, ): super().__init__() self.conv = Conv2d( in_channels, out_channels, kernel_size, stride, padding, bias=False, ) self.bn = BatchNorm2d(out_channels) self.act = ReLU(num_channels=out_channels, inplace=True)
def get_resnet(encoder_name, pretrained=True): """ Returns a resnet18 or resnet50 model, with AdaptiveAvgPool2d :param adaptive_pool_dim: dimension of feature output from adaptive average pooling h * w :param pretrained: if the model should be Imagenet pretrained :return: model, cnn_features_dim """ if encoder_name == "resnet18": model = models.resnet18(pretrained=pretrained) latent_dim = 512 else: model = models.resnet50(pretrained=pretrained) latent_dim = 2048 children = ([BatchNorm2d(3)] + list(model.children())[:-2]) model = torch.nn.Sequential(*children) return model, latent_dim
def __init__(self, inplanes, planes, dilation): super(ASPP_module, self).__init__() if dilation == 1: kernel_size = 1 padding = 0 else: kernel_size = 3 padding = dilation self.atrous_convolution = nn.Conv2d(inplanes, planes, kernel_size=kernel_size, stride=1, padding=padding, dilation=dilation, bias=False) self.bn = BatchNorm2d(planes) self.relu = nn.ReLU() self._init_weight()
def __init__(self): super(Discriminator, self).__init__() self.conv = Sequential( Conv2d(in_channels=CONFIG["IMAGE_CHANNEL"], out_channels=64, kernel_size=4, stride=2, padding=1), LeakyReLU(negative_slope=0.2), Conv2d(in_channels=64, out_channels=128, kernel_size=4, stride=2, padding=1), BatchNorm2d(num_features=128), LeakyReLU(negative_slope=0.2) ) self.fc = Sequential( Linear(128 * 7 * 7, 1024), BatchNorm1d(1024), LeakyReLU(negative_slope=0.2), Linear(1024, 1), Sigmoid() ) initialize_weights(self)
def __init__(self, num_layers, mode='ir'): super(Backbone, self).__init__() assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152' assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se' blocks = get_blocks(num_layers) if mode == 'ir': unit_module = bottleneck_IR elif mode == 'ir_se': unit_module = bottleneck_IR_SE self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False), BatchNorm2d(64), PReLU(64)) modules = [] for block in blocks: for bottleneck in block: modules.append( unit_module(bottleneck.in_channel, bottleneck.depth, bottleneck.stride)) self.body = Sequential(*modules)
def __init__(self, features, out_features=512, sizes=(1, 2, 3, 6)): super(PSPModule, self).__init__() self.stages = [] self.stages = nn.ModuleList( [self._make_stage(features, out_features, size) for size in sizes]) self.bottleneck = nn.Sequential( nn.Conv2d( features + len(sizes) * out_features, out_features, kernel_size=3, padding=1, dilation=1, bias=False, ), BatchNorm2d(out_features), nn.ReLU(), nn.Dropout2d(0.1), )
def _make_layer(self, block, planes, blocks, stride=1): downsample = None if stride != 1 or self.inplanes != planes * block.expansion: downsample = nn.Sequential( nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False), BatchNorm2d(planes * block.expansion), ) layers = [] layers.append(block(self.inplanes, planes, stride, downsample)) self.inplanes = planes * block.expansion for i in range(1, blocks): layers.append(block(self.inplanes, planes)) return nn.Sequential(*layers)
def __init__(self, num_layers, mode='ir', opts=None): super(GradualStyleEncoder, self).__init__() assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152' assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se' blocks = get_blocks(num_layers) if mode == 'ir': unit_module = bottleneck_IR elif mode == 'ir_se': unit_module = bottleneck_IR_SE self.input_layer = Sequential( Conv2d(opts.input_nc, 64, (3, 3), 1, 1, bias=False), BatchNorm2d(64), PReLU(64)) modules = [] for block in blocks: for bottleneck in block: modules.append( unit_module(bottleneck.in_channel, bottleneck.depth, bottleneck.stride)) self.body = Sequential(*modules) self.styles = nn.ModuleList() self.style_count = opts.n_styles self.coarse_ind = 3 self.middle_ind = 7 for i in range(self.style_count): if i < self.coarse_ind: style = GradualStyleBlock(512, 512, 16) elif i < self.middle_ind: style = GradualStyleBlock(512, 512, 32) else: style = GradualStyleBlock(512, 512, 64) self.styles.append(style) self.latlayer1 = nn.Conv2d(256, 512, kernel_size=1, stride=1, padding=0) self.latlayer2 = nn.Conv2d(128, 512, kernel_size=1, stride=1, padding=0)
def _make_layer(self, block, planes, blocks, stride=1, dilation=1, multi_grid=1): downsample = None if stride != 1 or self.inplanes != planes * block.expansion: downsample = nn.Sequential( nn.Conv2d( self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False, ), BatchNorm2d(planes * block.expansion, affine=True), ) layers = [] generate_multi_grid = (lambda index, grids: grids[index % len(grids)] if isinstance(grids, tuple) else 1) layers.append( block( self.inplanes, planes, stride, dilation=dilation, downsample=downsample, multi_grid=generate_multi_grid(0, multi_grid), )) self.inplanes = planes * block.expansion for i in range(1, blocks): layers.append( block( self.inplanes, planes, dilation=dilation, multi_grid=generate_multi_grid(i, multi_grid), )) return nn.Sequential(*layers)
def __init__(self, in_c, out_c, kernel=(1, 1), stride=(1, 1), padding=(0, 0), groups=1): super(Conv_block, self).__init__() self.conv = Conv2d( in_c, out_channels=out_c, kernel_size=kernel, groups=groups, stride=stride, padding=padding, bias=False, ) self.bn = BatchNorm2d(out_c) self.prelu = PReLU(out_c)
def conv(in_channels, out_channels, kernel_size=3, padding=1, batch_norm=True): """ A convolution block with a conv layer and batch norm :param in_channels: number of input channels :param out_channels: number of output channels :param kernel_size: size of the kernel :param padding: number of pixels to pad on all sides :param batch_norm: to use batch norm or not :return: PyTorch Tensor """ c = Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=1, padding=padding) if batch_norm: bn = BatchNorm2d(out_channels) return Sequential(c, bn) return c
def __init__(self): super(Generator, self).__init__() self.fc = Sequential( Linear(CONFIG["NOISE_DIM"] + 10, 1024), BatchNorm1d(1024), ReLU(), Linear(1024, 128 * 7 * 7), BatchNorm1d(128 * 7 * 7), ReLU(), ) self.deconv = Sequential( ConvTranspose2d(128, 64, 4, 2, 1), BatchNorm2d(64), ReLU(), ConvTranspose2d(64, CONFIG["IMAGE_CHANNEL"], 4, 2, 1), Tanh(), ) normal_init(self)
def __init__(self): super(GCPACC2Net, self).__init__() self.hardnet = hardnet(arch=68) inplanes = 1024 interplanes = 256 self.fam45 = FAM(640, interplanes, interplanes, interplanes) self.fam34 = FAM(320, interplanes, interplanes, interplanes) self.fam23 = FAM(128, interplanes, interplanes, interplanes) self.linear5 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.linear4 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.linear3 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.linear2 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.conva = nn.Sequential( nn.Conv2d(inplanes, interplanes, 3, padding=1, bias=False), BatchNorm2d(interplanes), nn.ReLU(interplanes), ) self.long_relation = CrissCrossAttention(interplanes) self.local_attention_4 = LocalAttenModule(interplanes) self.local_attention_3 = LocalAttenModule(interplanes) self.local_attention_2 = LocalAttenModule(interplanes)
def __init__(self, in_channels, out_channels): super(ASPP, self).__init__() dilations = [1, 6, 12, 18] self.aspp0 = _ASPPModule(in_channels=in_channels, out_channels=out_channels, kernel_size=1, padding=0, dilation=dilations[0]) self.aspp1 = _ASPPModule(in_channels=in_channels, out_channels=out_channels, kernel_size=3, padding=dilations[1], dilation=dilations[1]) self.aspp2 = _ASPPModule(in_channels=in_channels, out_channels=out_channels, kernel_size=3, padding=dilations[2], dilation=dilations[2]) self.aspp3 = _ASPPModule(in_channels=in_channels, out_channels=out_channels, kernel_size=3, padding=dilations[3], dilation=dilations[3]) self.conv = Conv2d(out_channels * 4, out_channels, kernel_size=3, stride=1, padding=1, dilation=1, groups=1, bias=True) self.relu = ReLU() self.batchnorm = BatchNorm2d(out_channels) self._init_weight()
def generatePathBNs(self, srcLayer): if self != srcLayer: # get current BN currBN = self.orgBNs()[self.currWidthIdx()] # get current BN num_features bnFeatures = currBN.num_features # generate new BNs ModuleList newBNs = ModuleList([ BatchNorm2d(bnFeatures) for _ in range(self.nWidths()) ]).cuda() # copy weights to new BNs for bn in newBNs: bn.load_state_dict(currBN.state_dict()) # set layer BNs self.bn = newBNs # update width List self._widthList = [self.currWidth()] * self.nWidths() # update width ratio list self._widthRatioList = [self.currWidthRatio()] * self.nWidths()
def _create_backbone(self): backbone = Sequential() section1 = Sequential() section1.add_module('Conv1', Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1)) section1.add_module('BatchNorm1', BatchNorm2d(num_features=32)) section1.add_module('Activation1', LeakyReLU(negative_slope=.1, inplace=True)) backbone.add_module('Section1', section1) backbone.add_module('Section2', YOLOv3Block(index=2, in_channels=32, out_channels=64, convs_residual_count=1)) backbone.add_module('Section3', YOLOv3Block(index=5, in_channels=64, out_channels=128, convs_residual_count=2)) backbone.add_module('Section4', YOLOv3Block(index=10, in_channels=128, out_channels=256, convs_residual_count=8)) backbone.add_module('Section5', YOLOv3Block(index=27, in_channels=256, out_channels=512, convs_residual_count=8)) backbone.add_module('Section6', YOLOv3Block(index=44, in_channels=512, out_channels=1024, convs_residual_count=4)) return backbone
def __init__(self, number_of_classes, anchors_dims): super(Tail, self).__init__() self.num_of_yolo_layers = 3 route_streams = [0, 2**3, 2**2] self.tails = ModuleList([ ModuleList([ Sequential( Conv2d((2**(5 - i) + route_streams[i]) * filters_multiplier, 2**(4 - i) * filters_multiplier, **bottleneck), BatchNorm2d(2**(4 - i) * filters_multiplier), LeakyReLU(negative_slope), Conv2d(2**(4 - i) * filters_multiplier, 2**(5 - i) * filters_multiplier, **casual), BatchNorm2d(2**(5 - i) * filters_multiplier), LeakyReLU(negative_slope), Conv2d(2**(5 - i) * filters_multiplier, 2**(4 - i) * filters_multiplier, **bottleneck), BatchNorm2d(2**(4 - i) * filters_multiplier), LeakyReLU(negative_slope), Conv2d(2**(4 - i) * filters_multiplier, 2**(5 - i) * filters_multiplier, **casual), BatchNorm2d(2**(5 - i) * filters_multiplier), LeakyReLU(negative_slope)), Sequential( Conv2d(2**(5 - i) * filters_multiplier, 2**(4 - i) * filters_multiplier, **bottleneck), BatchNorm2d(2**(4 - i) * filters_multiplier), LeakyReLU(negative_slope)), Sequential( Conv2d(2**(4 - i) * filters_multiplier, 2**(5 - i) * filters_multiplier, **casual), BatchNorm2d(2**(5 - i) * filters_multiplier), LeakyReLU(negative_slope)), Sequential( Conv2d(2**(5 - i) * filters_multiplier, anchors_dims[i] * (number_of_classes + 5), **prelude)) ] + [ Sequential( Conv2d(2**(4 - i) * filters_multiplier, 2** (3 - i) * filters_multiplier, **bottleneck), BatchNorm2d(2**(3 - i) * filters_multiplier), LeakyReLU(negative_slope)) ] * (i < 2)) for i in range(self.num_of_yolo_layers) ])
def __init__(self, cfg): super(ConvResStem, self).__init__() C1 = cfg.MODEL.RESNETS.CONVRESSTEM.CONV_CHANNEL C2 = cfg.MODEL.RESNETS.CONVRESSTEM.RES_CHANNEL1 n2 = cfg.MODEL.RESNETS.CONVRESSTEM.NUM_BLOCK_RES1 C3 = cfg.MODEL.RESNETS.STEM_OUT_CHANNELS n3 = cfg.MODEL.RESNETS.CONVRESSTEM.NUM_BLOCK_RES2 res_module = cfg.MODEL.RESNETS.TRANS_FUNC block_module = _TRANSFORMATION_MODULES[res_module] convs = [] convs.append(conv3x3(3, C1)) from torch.nn import BatchNorm2d convs.append(BatchNorm2d(C1)) convs.append(nn.ReLU(inplace=True)) self.stem_conv = nn.Sequential(*convs) self.stem_res2 = _make_stage( block_module, in_channels=C1, bottleneck_channels=C2//4, out_channels=C2, block_count=n2, num_groups=1, stride_in_1x1=cfg.MODEL.RESNETS.STRIDE_IN_1X1, first_stride=1, dilation=1, dcn_config={}, ) self.stem_res3 = _make_stage( block_module, in_channels=C2, bottleneck_channels=C3//4, out_channels=C3, block_count=n3, num_groups=1, stride_in_1x1=cfg.MODEL.RESNETS.STRIDE_IN_1X1, first_stride=2, dilation=1, dcn_config={}, )
def __init__(self): super(GCPAPSPSmallNet, self).__init__() self.hardnet = hardnet(arch=68) inplanes = 1024 interplanes = 128 self.fam45 = FAM(640, interplanes, interplanes, interplanes) self.fam34 = FAM(320, interplanes, interplanes, interplanes) self.fam23 = FAM(128, interplanes, interplanes, interplanes) self.linear5 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.linear4 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.linear3 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.linear2 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.conva = nn.Sequential( nn.Conv2d(inplanes, interplanes, 3, padding=1, bias=False), BatchNorm2d(interplanes), nn.ReLU(interplanes), ) # self.long_relation = SpatialCGNL(interplanes, interplanes // 2) self.long_relation = PSPModule(inplanes, interplanes) self.local_attention_4 = SmallLocalAttenModule(interplanes) self.local_attention_3 = SmallLocalAttenModule(interplanes) self.local_attention_2 = SmallLocalAttenModule(interplanes)
def __init__(self, k=1, n=28, drop_rate=0): super(WideResnetBackbone, self).__init__() self.k, self.n = k, n assert (self.n - 4) % 6 == 0 n_blocks = (self.n - 4) // 6 n_layers = [ 16, ] + [self.k * 16 * (2**i) for i in range(3)] self.conv1 = nn.Conv2d(3, n_layers[0], kernel_size=3, stride=1, padding=1, bias=False) self.layer1 = self.create_layer( n_layers[0], n_layers[1], bnum=n_blocks, stride=1, drop_rate=drop_rate, pre_res_act=True, ) self.layer2 = self.create_layer( n_layers[1], n_layers[2], bnum=n_blocks, stride=2, drop_rate=drop_rate, pre_res_act=False, ) self.layer3 = self.create_layer( n_layers[2], n_layers[3], bnum=n_blocks, stride=2, drop_rate=drop_rate, pre_res_act=False, ) self.bn_last = BatchNorm2d(n_layers[3], momentum=0.001) self.relu_last = nn.LeakyReLU(inplace=True, negative_slope=0.1) self.init_weight()
def __init__(self): super(GCPACGNLResNet, self).__init__() self.bkbone = ResNet() inplanes = 2048 interplanes = 256 self.fam45 = FAM(1024, interplanes, interplanes, interplanes) self.fam34 = FAM(512, interplanes, interplanes, interplanes) self.fam23 = FAM(256, interplanes, interplanes, interplanes) self.linear5 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.linear4 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.linear3 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.linear2 = nn.Conv2d(interplanes, 1, kernel_size=3, stride=1, padding=1) self.conva = nn.Sequential( nn.Conv2d(inplanes, interplanes, 3, padding=1, bias=False), BatchNorm2d(interplanes), nn.ReLU(interplanes), ) self.long_relation = SpatialCGNL(interplanes, interplanes // 2) self.local_attention_4 = LocalAttenModule(interplanes) self.local_attention_3 = LocalAttenModule(interplanes) self.local_attention_2 = LocalAttenModule(interplanes) self.local_attention = LocalAttenModule(interplanes)
def __init__(self, num_classes=10): super().__init__() self.in_channels = 64 # First - Conv2D 7x7 with 2 stride -> BatchNorm2D -> ReLU -> MaxPool2D self.conv1 = Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = BatchNorm2d(64) self.relu = ReLU(inplace=True) self.sigmoid = Sigmoid() self.max_pool = MaxPool2d(kernel_size=3, stride=2, padding=1) # Setup residual parts block groups self.layer64 = self._make_residual_layer(out_channels=64, num_blocks=3) self.layer128 = self._make_residual_layer(out_channels=128, num_blocks=4, stride=2) self.layer256 = self._make_residual_layer(out_channels=256, num_blocks=6, stride=2) self.layer512 = self._make_residual_layer(out_channels=512, num_blocks=3, stride=2) self.avg_pool = AvgPool2d(kernel_size=(1, 1)) self.fc_downscale = Linear(32768, 512) self.fc_downscale_2 = Linear(512, 128) self.fc = Linear(128, num_classes) # Initialize weights 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)
def __init__(self, in_chan, out_chan, ks=3, stride=1, padding=1, *args, **kwargs): super(ConvBNReLU, self).__init__() self.conv = nn.Conv2d( in_chan, out_chan, kernel_size=ks, stride=stride, padding=padding, bias=False, ) self.bn = BatchNorm2d(out_chan) self.relu = nn.ReLU6(inplace=True) self.init_weight()