def __init__(self, in_channels, output_stride): super(ASSP, self).__init__() assert output_stride in [ 8, 16 ], "Only output strides of 8 or 16 are suported" if output_stride == 16: dilations = [1, 6, 12, 18] elif output_stride == 8: dilations = [1, 12, 24, 36] self.aspp1 = assp_branch(in_channels, 256, 1, dilation=dilations[0]) self.aspp2 = assp_branch(in_channels, 256, 3, dilation=dilations[1]) self.aspp3 = assp_branch(in_channels, 256, 3, dilation=dilations[2]) self.aspp4 = assp_branch(in_channels, 256, 3, dilation=dilations[3]) self.avg_pool = nn.Sequential( nn.AdaptiveAvgPool2d((1, 1)), nn.Conv2d(in_channels, 256, 1, bias=False), nn.BatchNorm2d(256), nn.ReLU(inplace=True), ) self.conv1 = nn.Conv2d(256 * 5, 256, 1, bias=False) self.bn1 = nn.BatchNorm2d(256) self.relu = nn.ReLU(inplace=True) self.dropout = nn.Dropout(0.5) initialize_weights(self)
def __init__(self, in_channels, backbone, out_channels_gcn=(85, 128), pretrained=True, kernel_sizes=(5, 7)): super(Resnet, self).__init__() resnet = getattr(torchvision.models, backbone)(pretrained) if in_channels == 3: conv1 = resnet.conv1 else: conv1 = nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3, bias=False) self.initial = nn.Sequential(conv1, resnet.bn1, resnet.relu, resnet.maxpool) self.layer1 = resnet.layer1 self.layer2 = resnet.layer2 self.layer3 = resnet.layer3 self.layer4 = resnet.layer4 if not pretrained: initialize_weights(self)
def __init__(self, output_stride=16, in_channels=3, pretrained=True): super(Xception, self).__init__() # Stride for block 3 (entry flow), and the dilation rates for middle flow and exit flow if output_stride == 16: b3_s, mf_d, ef_d = 2, 1, (1, 2) if output_stride == 8: b3_s, mf_d, ef_d = 1, 2, (2, 4) # Entry Flow self.conv1 = nn.Conv2d(in_channels, 32, 3, 2, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(32) self.relu = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(32, 64, 3, 1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(64) self.block1 = Block(64, 128, stride=2, dilation=1, use_1st_relu=False) self.block2 = Block(128, 256, stride=2, dilation=1) self.block3 = Block(256, 728, stride=b3_s, dilation=1) # Middle Flow for i in range(16): exec(f'self.block{i+4} = Block(728, 728, stride=1, dilation=mf_d)') # Exit flow self.block20 = Block(728, 1024, stride=1, dilation=ef_d[0], exit_flow=True) self.conv3 = SeparableConv2d(1024, 1536, 3, stride=1, dilation=ef_d[1]) self.bn3 = nn.BatchNorm2d(1536) self.conv4 = SeparableConv2d(1536, 1536, 3, stride=1, dilation=ef_d[1]) self.bn4 = nn.BatchNorm2d(1536) self.conv5 = SeparableConv2d(1536, 2048, 3, stride=1, dilation=ef_d[1]) self.bn5 = nn.BatchNorm2d(2048) initialize_weights(self) if pretrained: self._load_pretrained_model()
def __init__(self, num_classes, in_channels=3, backbone="resnet50", pretrained=True, freeze_bn=False, freeze_backbone=False, **kwargs): super(UNetResnet, self).__init__() model = getattr(resnet, backbone)(pretrained, norm_layer=nn.BatchNorm2d) self.initial = list(model.children())[:4] if in_channels != 3: self.initial[0] = nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3, bias=False) self.initial = nn.Sequential(*self.initial) # encoder self.layer1 = model.layer1 self.layer2 = model.layer2 self.layer3 = model.layer3 self.layer4 = model.layer4 # decoder self.conv1 = nn.Conv2d(2048, 192, kernel_size=3, stride=1, padding=1) self.upconv1 = nn.ConvTranspose2d(192, 128, 4, 2, 1, bias=False) self.conv2 = nn.Conv2d(1152, 128, kernel_size=3, stride=1, padding=1) self.upconv2 = nn.ConvTranspose2d(128, 96, 4, 2, 1, bias=False) self.conv3 = nn.Conv2d(608, 96, kernel_size=3, stride=1, padding=1) self.upconv3 = nn.ConvTranspose2d(96, 64, 4, 2, 1, bias=False) self.conv4 = nn.Conv2d(320, 64, kernel_size=3, stride=1, padding=1) self.upconv4 = nn.ConvTranspose2d(64, 48, 4, 2, 1, bias=False) self.conv5 = nn.Conv2d(48, 48, kernel_size=3, stride=1, padding=1) self.upconv5 = nn.ConvTranspose2d(48, 32, 4, 2, 1, bias=False) self.conv6 = nn.Conv2d(32, 32, kernel_size=3, stride=1, padding=1) self.conv7 = nn.Conv2d(32, num_classes, kernel_size=1, bias=False) initialize_weights(self) if freeze_bn: self.freeze_bn() if freeze_backbone: set_trainable( [ self.initial, self.layer1, self.layer2, self.layer3, self.layer4 ], False, )
def __init__(self, num_classes, in_channels=3, freeze_bn=False, **_): super(ENet, self).__init__() self.initial = InitalBlock(in_channels) # Stage 1 self.bottleneck10 = BottleNeck(16, 64, downsample=True, p_drop=0.01) self.bottleneck11 = BottleNeck(64, p_drop=0.01) self.bottleneck12 = BottleNeck(64, p_drop=0.01) self.bottleneck13 = BottleNeck(64, p_drop=0.01) self.bottleneck14 = BottleNeck(64, p_drop=0.01) # Stage 2 self.bottleneck20 = BottleNeck(64, 128, downsample=True, p_drop=0.1) self.bottleneck21 = BottleNeck(128, p_drop=0.1) self.bottleneck22 = BottleNeck(128, dilation=2, p_drop=0.1) self.bottleneck23 = BottleNeck(128, asymetric=True, p_drop=0.1) self.bottleneck24 = BottleNeck(128, dilation=4, p_drop=0.1) self.bottleneck25 = BottleNeck(128, p_drop=0.1) self.bottleneck26 = BottleNeck(128, dilation=8, p_drop=0.1) self.bottleneck27 = BottleNeck(128, asymetric=True, p_drop=0.1) self.bottleneck28 = BottleNeck(128, dilation=16, p_drop=0.1) # Stage 3 self.bottleneck31 = BottleNeck(128, p_drop=0.1) self.bottleneck32 = BottleNeck(128, dilation=2, p_drop=0.1) self.bottleneck33 = BottleNeck(128, asymetric=True, p_drop=0.1) self.bottleneck34 = BottleNeck(128, dilation=4, p_drop=0.1) self.bottleneck35 = BottleNeck(128, p_drop=0.1) self.bottleneck36 = BottleNeck(128, dilation=8, p_drop=0.1) self.bottleneck37 = BottleNeck(128, asymetric=True, p_drop=0.1) self.bottleneck38 = BottleNeck(128, dilation=16, p_drop=0.1) # Stage 4 self.bottleneck40 = BottleNeck(128, 64, upsample=True, p_drop=0.1, use_prelu=False) self.bottleneck41 = BottleNeck(64, p_drop=0.1, use_prelu=False) self.bottleneck42 = BottleNeck(64, p_drop=0.1, use_prelu=False) # Stage 5 self.bottleneck50 = BottleNeck(64, 16, upsample=True, p_drop=0.1, use_prelu=False) self.bottleneck51 = BottleNeck(16, p_drop=0.1, use_prelu=False) # Stage 6 self.fullconv = nn.ConvTranspose2d(16, num_classes, kernel_size=3, padding=1, output_padding=1, stride=2, bias=False) initialize_weights(self) if freeze_bn: self.freeze_bn()
def __init__(self, shape, r, learn_rate=0.1, beta=0., momentum=0.): m, n = shape[0], shape[1] self.U = initialize_weights(m,r) self.G = initialize_weights(r,n) self.bias = zeros((m,n)) self.shape = (m, n) self.r = r self.prevgrad = zeros(len(self.params)) self.trainer = ActivationTrainer()
def __init__(self, num_channels): super(BR_Block, self).__init__() self.bn1 = nn.BatchNorm2d(num_channels) self.relu1 = nn.ReLU(inplace=True) self.conv1 = nn.Conv2d(num_channels, num_channels, 3, padding=1) self.bn2 = nn.BatchNorm2d(num_channels) self.relu2 = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(num_channels, num_channels, 3, padding=1) initialize_weights(self)
def __init__(self, num_classes=8, in_channels=3, backbone='resnet152', pretrained=False, use_aux=True, freeze_bn=False, freeze_backbone=False): super(PSPNet, self).__init__() # TODO: Use synch batchnorm norm_layer = nn.BatchNorm2d model = getattr(resnet, backbone)( pretrained=False, norm_layer=norm_layer, ) m_out_sz = model.fc.in_features self.use_aux = use_aux self.initial = nn.Sequential(*list(model.children())[:4]) if in_channels != 3: self.initial[0] = nn.Conv2d(in_channels, 128, kernel_size=7, stride=2, padding=3, bias=False) self.initial = nn.Sequential(*self.initial) self.layer1 = model.layer1 self.layer2 = model.layer2 self.layer3 = model.layer3 self.layer4 = model.layer4 self.master_branch = nn.Sequential( _PSPModule(m_out_sz, bin_sizes=[1, 2, 3, 6], norm_layer=norm_layer), nn.Conv2d(m_out_sz // 4, num_classes, kernel_size=1)) self.auxiliary_branch = nn.Sequential( nn.Conv2d(m_out_sz // 2, m_out_sz // 4, kernel_size=3, padding=1, bias=False), norm_layer(m_out_sz // 4), nn.ReLU(inplace=True), nn.Dropout2d(0.1), nn.Conv2d(m_out_sz // 4, num_classes, kernel_size=1)) initialize_weights(self.master_branch, self.auxiliary_branch) if freeze_bn: self.freeze_bn() if freeze_backbone: set_trainable([ self.initial, self.layer1, self.layer2, self.layer3, self.layer4 ], False)
def __init__(self, num_classes, in_channels=3, backbone='densenet201', pretrained=True, use_aux=True, freeze_bn=False, **_): super(PSPDenseNet, self).__init__() self.use_aux = use_aux model = getattr(models, backbone)(pretrained) m_out_sz = model.classifier.in_features aux_out_sz = model.features.transition3.conv.out_channels if not pretrained or in_channels != 3: # If we're training from scratch, better to use 3x3 convs block0 = [nn.Conv2d(in_channels, 64, 3, stride=2, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True)] block0.extend( [nn.Conv2d(64, 64, 3, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True)] * 2 ) self.block0 = nn.Sequential( *block0, nn.MaxPool2d(kernel_size=3, stride=2, padding=1) ) initialize_weights(self.block0) else: self.block0 = nn.Sequential(*list(model.features.children())[:4]) self.block1 = model.features.denseblock1 self.block2 = model.features.denseblock2 self.block3 = model.features.denseblock3 self.block4 = model.features.denseblock4 self.transition1 = model.features.transition1 # No pooling self.transition2 = nn.Sequential( *list(model.features.transition2.children())[:-1]) self.transition3 = nn.Sequential( *list(model.features.transition3.children())[:-1]) for n, m in self.block3.named_modules(): if 'conv2' in n: m.dilation, m.padding = (2,2), (2,2) for n, m in self.block4.named_modules(): if 'conv2' in n: m.dilation, m.padding = (4,4), (4,4) self.master_branch = nn.Sequential( _PSPModule(m_out_sz, bin_sizes=[1, 2, 3, 6], norm_layer=nn.BatchNorm2d), nn.Conv2d(m_out_sz//4, num_classes, kernel_size=1) ) self.auxiliary_branch = nn.Sequential( nn.Conv2d(aux_out_sz, m_out_sz//4, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(m_out_sz//4), nn.ReLU(inplace=True), nn.Dropout2d(0.1), nn.Conv2d(m_out_sz//4, num_classes, kernel_size=1) ) initialize_weights(self.master_branch, self.auxiliary_branch) if freeze_bn: self.freeze_bn()
def __init__(self, in_channels, out_channles, upscale): super(DUC, self).__init__() out_channles = out_channles * (upscale**2) self.conv = nn.Conv2d(in_channels, out_channles, 1, bias=False) self.bn = nn.BatchNorm2d(out_channles) self.relu = nn.ReLU(inplace=True) self.pixl_shf = nn.PixelShuffle(upscale_factor=upscale) initialize_weights(self) kernel = self.icnr(self.conv.weight, scale=upscale) self.conv.weight.data.copy_(kernel)
def __init__(self, in_channels, output_stride, pretrained=True, dilation_bigger=False): super(ResNet_HDC_DUC, self).__init__() model = models.resnet101(pretrained=pretrained) if not pretrained or in_channels != 3: self.layer0 = nn.Sequential( nn.Conv2d(in_channels, 64, 7, stride=2, padding=3, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1)) initialize_weights(self.layer0) else: self.layer0 = nn.Sequential(*list(model.children())[:4]) self.layer1 = model.layer1 self.layer2 = model.layer2 self.layer3 = model.layer3 self.layer4 = model.layer4 if output_stride == 4: list(self.layer0.children())[0].stride = (1, 1) d_res4b = [] if dilation_bigger: d_res4b.extend([1, 2, 5, 9] * 5 + [1, 2, 5]) d_res5b = [5, 9, 17] else: # Dialtion-RF d_res4b.extend([1, 2, 3] * 7 + [2, 2]) d_res5b = [3, 4, 5] l_index = 0 for n, m in self.layer3.named_modules(): if 'conv2' in n: d = d_res4b[l_index] m.dilation, m.padding, m.stride = (d, d), (d, d), (1, 1) l_index += 1 elif 'downsample.0' in n: m.stride = (1, 1) l_index = 0 for n, m in self.layer4.named_modules(): if 'conv2' in n: d = d_res5b[l_index] m.dilation, m.padding, m.stride = (d, d), (d, d), (1, 1) l_index += 1 elif 'downsample.0' in n: m.stride = (1, 1)
def __init__(self, in_channels=3, output_stride=16, backbone="resnet101", pretrained=True): super(ResNet, self).__init__() model = getattr(models, backbone)(pretrained) if not pretrained or in_channels != 3: self.layer0 = nn.Sequential( nn.Conv2d(in_channels, 64, 7, stride=2, padding=3, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1), ) initialize_weights(self.layer0) else: self.layer0 = nn.Sequential(*list(model.children())[:4]) self.layer1 = model.layer1 self.layer2 = model.layer2 self.layer3 = model.layer3 self.layer4 = model.layer4 if output_stride == 16: s3, s4, d3, d4 = (2, 1, 1, 2) elif output_stride == 8: s3, s4, d3, d4 = (1, 1, 2, 4) if output_stride == 8: for n, m in self.layer3.named_modules(): if "conv1" in n and (backbone == "resnet34" or backbone == "resnet18"): m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3, s3) elif "conv2" in n: m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3, s3) elif "downsample.0" in n: m.stride = (s3, s3) for n, m in self.layer4.named_modules(): if "conv1" in n and (backbone == "resnet34" or backbone == "resnet18"): m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4) elif "conv2" in n: m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4) elif "downsample.0" in n: m.stride = (s4, s4)
def __init__(self, visible_size, hidden_size, epochs=1, learn_rate=0.1, trainfn='cdn', n=1, beta=0.0001, momentum=0., batch_size=10, visible_layer='binary', hidden_layer='binary', dropout=0.0, verbose=0): # Initialize args self.trainfn = trainfn self.epochs = epochs self.n = n self.learn_rate = learn_rate self.beta = beta self.batch_size = batch_size self.momentum = momentum self.verbose = verbose self.visible_size = visible_size self.hidden_size = hidden_size self.visible_layer = visible_layer self.hidden_layer = hidden_layer self.dropout = dropout # Initialize Biases and Weights self.vbias = zeros(visible_size) self.hbias = zeros(hidden_size) self.W = initialize_weights(visible_size, hidden_size) self.prevgrad = {'W': zeros(self.W.shape), 'hbias': zeros(hidden_size), 'vbias': zeros(visible_size)} self.p = np.zeros((self.batch_size, self.hidden_size)) if self.trainfn == 'fpcd': self.fW = zeros(self.W.shape) self.flr = self.learn_rate*exp(1) #fast learn rate heuristic self.fWd = 49./50 #fast weight decay heuristic # Initialize Trainer instance self.trainer = Trainer()
def __init__(self, in_channels, bin_sizes, norm_layer=nn.BatchNorm2d): super().__init__() out_channels = in_channels // len(bin_sizes) self.bin_sizes = bin_sizes self.stages = nn.ModuleList([ self._make_stages(in_channels, out_channels, b_s, norm_layer) for b_s in bin_sizes ]) self.bottleneck = nn.Sequential( nn.Conv2d(in_channels + (out_channels * len(bin_sizes)), out_channels, kernel_size=3, padding=1, bias=False), norm_layer(out_channels), nn.ReLU(inplace=True), nn.Dropout2d(0.1)) initialize_weights(self)
def __init__(self, low_level_channels, num_classes): super(Decoder, self).__init__() self.conv1 = nn.Conv2d(low_level_channels, 48, 1, bias=False) self.bn1 = nn.BatchNorm2d(48) self.relu = nn.ReLU(inplace=True) self.DUC = DUC(256, 256, upscale=2) self.output = nn.Sequential( nn.Conv2d(48 + 256, 256, 3, stride=1, padding=1, bias=False), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.Conv2d(256, 256, 3, stride=1, padding=1, bias=False), nn.BatchNorm2d(256), nn.ReLU(inplace=True), nn.Dropout(0.1), nn.Conv2d(256, num_classes, 1, stride=1), ) initialize_weights(self)
def __init__(self, in_channels, output_stride, assp_channels=6): super(ASSP, self).__init__() assert output_stride in [ 4, 8 ], 'Only output strides of 8 or 16 are suported' assert assp_channels in [ 4, 6 ], 'Number of suported ASSP branches are 4 or 6' dilations = [1, 6, 12, 18, 24, 36] dilations = dilations[:assp_channels] self.assp_channels = assp_channels self.aspp1 = assp_branch(in_channels, 256, 1, dilation=dilations[0]) self.aspp2 = assp_branch(in_channels, 256, 3, dilation=dilations[1]) self.aspp3 = assp_branch(in_channels, 256, 3, dilation=dilations[2]) self.aspp4 = assp_branch(in_channels, 256, 3, dilation=dilations[3]) if self.assp_channels == 6: self.aspp5 = assp_branch(in_channels, 256, 3, dilation=dilations[4]) self.aspp6 = assp_branch(in_channels, 256, 3, dilation=dilations[5]) self.avg_pool = nn.Sequential( nn.AdaptiveAvgPool2d((1, 1)), nn.Conv2d(in_channels, 256, 1, bias=False), nn.BatchNorm2d(256), nn.ReLU(inplace=True)) self.conv1 = nn.Conv2d(256 * (self.assp_channels + 1), 256, 1, bias=False) self.bn1 = nn.BatchNorm2d(256) self.relu = nn.ReLU(inplace=True) self.dropout = nn.Dropout(0.5) initialize_weights(self)
def __init__(self, size_in, size_out, learn_rate=0.1, epochs=1, batch_size=100, momentum=0.9, verbose=0): self.size_in = size_in self.size_out = size_out self.learn_rate = learn_rate self.epochs = epochs self.batch_size = batch_size self.verbose = verbose self.momentum = momentum self.W = initialize_weights(size_in, size_out) self._prevgrad = zeros(self.W.flatten().shape) self.trainer = Trainer()
def __init__(self, kernel_size, in_channels, out_channels): super(GCN_Block, self).__init__() assert kernel_size % 2 == 1, 'Kernel size must be odd' self.conv11 = nn.Conv2d(in_channels, out_channels, kernel_size=(kernel_size, 1), padding=(kernel_size // 2, 0)) self.conv12 = nn.Conv2d(out_channels, out_channels, kernel_size=(1, kernel_size), padding=(0, kernel_size // 2)) self.conv21 = nn.Conv2d(in_channels, out_channels, kernel_size=(1, kernel_size), padding=(0, kernel_size // 2)) self.conv22 = nn.Conv2d(out_channels, out_channels, kernel_size=(kernel_size, 1), padding=(kernel_size // 2, 0)) initialize_weights(self)
def __init__(self, in_channels, backbone, out_channels_gcn=(85, 128), kernel_sizes=(5, 7)): super(ResnetGCN, self).__init__() resnet = getattr(torchvision.models, backbone)(pretrained=False) if in_channels == 3: conv1 = resnet.conv1 else: conv1 = nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3, bias=False) self.initial = nn.Sequential(conv1, resnet.bn1, resnet.relu, resnet.maxpool) self.layer1 = resnet.layer1 self.layer2 = resnet.layer2 self.layer3 = nn.Sequential( BottleneckGCN(512, 1024, kernel_sizes[0], out_channels_gcn[0], stride=2), *[BottleneckGCN(1024, 1024, kernel_sizes[0], out_channels_gcn[0]) ] * 5) self.layer4 = nn.Sequential( BottleneckGCN(1024, 2048, kernel_sizes[1], out_channels_gcn[1], stride=2), *[BottleneckGCN(1024, 1024, kernel_sizes[1], out_channels_gcn[1]) ] * 5) initialize_weights(self)
def __init__(self, in_channels=3, output_stride=16, backbone='resnet101', pretrained=True): super(ResNetFuse, self).__init__() # Encoder Depth model_d = getattr(models, backbone)(pretrained) in_channels_d = 1 state_dict = model_d.state_dict() conv1_weight = state_dict['conv1.weight'] conv1_weight = conv1_weight.mean(dim=1, keepdim=True) conv2d_first = nn.Conv2d(in_channels_d, 64, 7, stride=2, padding=3, bias=False) conv2d_first.weight.data = conv1_weight #print("backbone {}".format(backbone)) #_load_pretrained(model_d, model_urls[backbone], inchans=in_channels_d) # self.layer0_d = nn.Sequential(*list(model_d.children())[:4]) self.layer0_d = nn.Sequential( conv2d_first, nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1)) #initialize_weights(self.layer0_d) self.layer1_d = model_d.layer1 self.layer2_d = model_d.layer2 self.layer3_d = model_d.layer3 self.layer4_d = model_d.layer4 if output_stride == 16: s3, s4, d3, d4 = (2, 1, 1, 2) elif output_stride == 8: s3, s4, d3, d4 = (1, 1, 2, 4) if output_stride == 8: for n, m in self.layer3_d.named_modules(): if 'conv1' in n and (backbone == 'resnet34' or backbone == 'resnet18'): m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3, s3) elif 'conv2' in n: m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3, s3) elif 'downsample.0' in n: m.stride = (s3, s3) for n, m in self.layer4_d.named_modules(): if 'conv1' in n and (backbone == 'resnet34' or backbone == 'resnet18'): m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4) elif 'conv2' in n: m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4) elif 'downsample.0' in n: m.stride = (s4, s4) #Encoder RGB model = getattr(models, backbone)(pretrained) if not pretrained or in_channels != 3: self.layer0 = nn.Sequential( nn.Conv2d(in_channels, 64, 7, stride=2, padding=3, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1)) initialize_weights(self.layer0) else: self.layer0 = nn.Sequential(*list(model.children())[:4]) self.layer1 = model.layer1 self.layer2 = model.layer2 self.layer3 = model.layer3 self.layer4 = model.layer4 if output_stride == 16: s3, s4, d3, d4 = (2, 1, 1, 2) elif output_stride == 8: s3, s4, d3, d4 = (1, 1, 2, 4) if output_stride == 8: for n, m in self.layer3.named_modules(): if 'conv1' in n and (backbone == 'resnet34' or backbone == 'resnet18'): m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3, s3) elif 'conv2' in n: m.dilation, m.padding, m.stride = (d3, d3), (d3, d3), (s3, s3) elif 'downsample.0' in n: m.stride = (s3, s3) for n, m in self.layer4.named_modules(): if 'conv1' in n and (backbone == 'resnet34' or backbone == 'resnet18'): m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4) elif 'conv2' in n: m.dilation, m.padding, m.stride = (d4, d4), (d4, d4), (s4, s4) elif 'downsample.0' in n: m.stride = (s4, s4)
def __init__(self, num_classes, in_channels=3, backbone='resnet152', pretrained=True, use_aux=True, freeze_bn=False, freeze_backbone=False): super().__init__() # TODO: Use synch batchnorm norm_layer = nn.BatchNorm2d # model = getattr(resnet, backbone)(pretrained, norm_layer=norm_layer) model = getattr(models, backbone)(pretrained) self.initial = nn.Sequential(*list(model.children())[:4]) if in_channels != 3: self.initial[0] = nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3, bias=False) self.initial = nn.Sequential(*self.initial) self.layer1 = model.layer1 self.layer2 = model.layer2 self.layer3 = model.layer3 self.layer4 = model.layer4 out_size1 = model.layer1[-1].bn3.num_features out_size2 = model.layer2[-1].bn3.num_features out_size3 = model.layer3[-1].bn3.num_features out_size4 = model.layer4[-1].bn3.num_features bin_sizes = [1, 2, 3, 6] self.ppm4 = nn.Sequential( PPM(out_size4, bin_sizes, norm_layer=norm_layer), nn.Conv2d(out_size4 // len(bin_sizes), num_classes, kernel_size=1)) self.ppm3 = nn.Sequential( PPM(out_size3, bin_sizes, norm_layer=norm_layer), nn.Conv2d(out_size3 // len(bin_sizes), num_classes, kernel_size=1)) self.ppm2 = nn.Sequential( PPM(out_size2, bin_sizes, norm_layer=norm_layer), nn.Conv2d(out_size2 // len(bin_sizes), num_classes, kernel_size=1)) self.daum = DAUM(in_channels, (9, 9)) self.daum1 = AUM(in_channels, (5, 5)) self.daum2 = AUM(in_channels, (5, 5)) self.daum3 = AUM(in_channels, (5, 5)) # self.daum4 = DAUM(512, (5, 5)) self.smoother = GaussianSmoother() initialize_weights(self.ppm4, self.ppm3, self.ppm2, self.daum1, self.daum2, self.daum3) if freeze_bn: self.freeze_bn() if freeze_backbone: set_trainable([ self.initial, self.layer1, self.layer2, self.layer3, self.layer4 ], False)
def __init__(self, size_in=10, size_out=10, modelfn='sigmoid', dropout=0.0): self._W = initialize_weights(size_in+1, size_out).astype(np.float128) self._size_in = size_in self._size_out = size_out self._modelfn = modelfn self.dropout = dropout