def __init__(self, in_channels: int, out_channels: int, index: int): super(SSH, self).__init__() self.in_channels = in_channels self.out_channels = out_channels self.half_out_channels = int(out_channels / 2) self.quater_out_channels = int(self.half_out_channels / 2) self.index = index self.ssh_3x3 = nn.Sequential( nn.Conv2d(in_channels=self.in_channels, out_channels=self.half_out_channels, kernel_size=3, stride=1, padding=1) ) self.ssh_dimred = nn.Sequential( nn.Conv2d(in_channels=self.in_channels, out_channels=self.quater_out_channels, kernel_size=3, stride=1, padding=1), nn.ReLU() ) self.ssh_5x5 = nn.Sequential( nn.Conv2d(in_channels=self.quater_out_channels, out_channels=self.quater_out_channels, kernel_size=3, stride=1, padding=1) ) self.ssh_7x7 = nn.Sequential( nn.Conv2d(in_channels=self.quater_out_channels, out_channels=self.quater_out_channels, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(in_channels=self.quater_out_channels, out_channels=self.quater_out_channels, kernel_size=3, stride=1, padding=1) ) self.out_relu = nn.ReLU()
def __init__(self, in_planes, out_planes, stride=1, scale=0.1, map_reduce=8, vision=1, groups=1): super(BasicRFB, self).__init__() self.scale = scale self.out_channels = out_planes inter_planes = in_planes // map_reduce self.branch0 = nn.Sequential( BasicConv(in_planes, inter_planes, kernel_size=1, stride=1, groups=groups, relu=False), BasicConv(inter_planes, 2 * inter_planes, kernel_size=(3, 3), stride=stride, padding=(1, 1), groups=groups), BasicConv(2 * inter_planes, 2 * inter_planes, kernel_size=3, stride=1, padding=vision + 1, dilation=vision + 1, relu=False, groups=groups) ) self.branch1 = nn.Sequential( BasicConv(in_planes, inter_planes, kernel_size=1, stride=1, groups=groups, relu=False), BasicConv(inter_planes, 2 * inter_planes, kernel_size=(3, 3), stride=stride, padding=(1, 1), groups=groups), BasicConv(2 * inter_planes, 2 * inter_planes, kernel_size=3, stride=1, padding=vision + 2, dilation=vision + 2, relu=False, groups=groups) ) self.branch2 = nn.Sequential( BasicConv(in_planes, inter_planes, kernel_size=1, stride=1, groups=groups, relu=False), BasicConv(inter_planes, (inter_planes // 2) * 3, kernel_size=3, stride=1, padding=1, groups=groups), BasicConv((inter_planes // 2) * 3, 2 * inter_planes, kernel_size=3, stride=stride, padding=1, groups=groups), BasicConv(2 * inter_planes, 2 * inter_planes, kernel_size=3, stride=1, padding=vision + 4, dilation=vision + 4, relu=False, groups=groups) ) self.ConvLinear = BasicConv(6 * inter_planes, out_planes, kernel_size=1, stride=1, relu=False) self.shortcut = BasicConv(in_planes, out_planes, kernel_size=1, stride=stride, relu=False) self.relu = nn.ReLU(inplace=False) self.eltadd = nn.EltAdd()
def multibox(self, num_classes): loc_layers = [] conf_layers = [] loc_layers += [nn.Conv2d(self.model3.out_channels, 3 * 14, kernel_size=3, padding=1, bias=True)] conf_layers += [nn.Conv2d(self.model3.out_channels, 3 * num_classes, kernel_size=3, padding=1, bias=True)] loc_layers += [nn.Conv2d(self.model4.out_channels, 2 * 14, kernel_size=3, padding=1, bias=True)] conf_layers += [nn.Conv2d(self.model4.out_channels, 2 * num_classes, kernel_size=3, padding=1, bias=True)] loc_layers += [nn.Conv2d(self.model5.out_channels, 2 * 14, kernel_size=3, padding=1, bias=True)] conf_layers += [nn.Conv2d(self.model5.out_channels, 2 * num_classes, kernel_size=3, padding=1, bias=True)] loc_layers += [nn.Conv2d(self.model6.out_channels, 3 * 14, kernel_size=3, padding=1, bias=True)] conf_layers += [nn.Conv2d(self.model6.out_channels, 3 * num_classes, kernel_size=3, padding=1, bias=True)] return nn.Sequential(*loc_layers), nn.Sequential(*conf_layers)
def build_conv_block(self, in_channels: int, out_channels: int, kernel_size: int = 3, stride: int = 1, padding: int = 1, n_conv: int = 2, with_pool: bool = False): layers = [] if with_pool: layers.append(nn.MaxPool2d(kernel_size=2, stride=2)) # convx_1 layers += [ nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding), nn.ReLU() ] # convx_2 -> convx_(n_conv) for i in range(1, n_conv): add_layers = [ nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding), nn.ReLU() ] layers += add_layers # return as sequential return nn.Sequential(*layers)
def multibox(self, num_classes): loc_layers = [] conf_layers = [] loc_layers += [nn.Conv2d(128, 21 * 4, kernel_size=3, padding=1)] conf_layers += [ nn.Conv2d(128, 21 * num_classes, kernel_size=3, padding=1) ] loc_layers += [nn.Conv2d(256, 1 * 4, kernel_size=3, padding=1)] conf_layers += [ nn.Conv2d(256, 1 * num_classes, kernel_size=3, padding=1) ] loc_layers += [nn.Conv2d(256, 1 * 4, kernel_size=3, padding=1)] conf_layers += [ nn.Conv2d(256, 1 * num_classes, kernel_size=3, padding=1) ] return nn.Sequential(*loc_layers), nn.Sequential(*conf_layers)
def __init__(self, in_channels, out_channels, kernel_sizes, strides=None, paddings=None, with_pool=True): super(Conv_Block, self).__init__() assert len(in_channels) == len(out_channels) assert len(out_channels) == len(kernel_sizes) if strides is not None: assert len(kernel_sizes) == len(strides) self.pool = None if with_pool: self.pool = nn.MaxPool2d(kernel_size=2, stride=2) groups = len(in_channels) convs = [] for i in range(groups): convs.append( nn.Conv2d(in_channels=in_channels[i], out_channels=out_channels[i], kernel_size=kernel_sizes[i], stride=strides[i], padding=paddings[i])) convs.append(nn.ReLU(inplace=True)) self.feature = nn.Sequential(*convs)
def __init__(self): super(LFFDv1, self).__init__() self.backbone = nn.Sequential( nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=2, padding=0), # downsample by 2 nn.ReLU(), nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=2, padding=0), # downsample by 2 ResBlock(64), ResBlock(64), ResBlock(64)) self.rb1 = ResBlock(64, det_out=True) self.det1 = DetBlock(64) self.relu_conv10 = nn.ReLU() self.conv11 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=2, padding=0) self.rb2 = ResBlock(64) self.det2 = DetBlock(64) self.rb3 = ResBlock(64, det_out=True) self.det3 = DetBlock(64) self.relu_conv15 = nn.ReLU() self.conv16 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=2, padding=0) self.rb4 = ResBlock(128) self.det4 = DetBlock(64) self.relu_conv18 = nn.ReLU() self.conv19 = nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=2, padding=0) self.rb5 = ResBlock(128) self.det5 = DetBlock(128) self.rb6 = ResBlock(128, det_out=True) self.det6 = DetBlock(128) self.rb7 = ResBlock(128, det_out=True) self.det7 = DetBlock(128) self.relu_conv25 = nn.ReLU() self.det8 = DetBlock(128)
def _conv_dw(in_channels, out_channels, stride): return nn.Sequential( nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=3, stride=stride, padding=1, groups=in_channels, bias=False), nn.BatchNorm2d(in_channels), nn.ReLU(inplace=True), nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True) )
def conv_dw(inp, oup, stride, leaky=0.1): return nn.Sequential( nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=False), nn.BatchNorm2d(inp), nn.LeakyReLU(negative_slope=leaky, inplace=True), nn.Conv2d(inp, oup, 1, 1, 0, bias=False), nn.BatchNorm2d(oup), nn.LeakyReLU(negative_slope=leaky, inplace=True), )
def __init__(self): super(LFFDv2, self).__init__() self.backbone = nn.Sequential( nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=2, padding=0), # downsample by 2 nn.ReLU(), nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=2, padding=0), # downsample by 2 ResBlock(64), ResBlock(64), ResBlock(64)) self.relu_conv8 = nn.ReLU() self.conv9 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=2, padding=0) # downsample by 2 self.rb1 = ResBlock(64) self.det1 = DetBlock(64) self.relu_conv11 = nn.ReLU() self.conv12 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=2, padding=0) # downsample by 2 self.rb2 = ResBlock(64) self.det2 = DetBlock(64) self.relu_conv14 = nn.ReLU() self.conv15 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=2, padding=0) # downsample by 2 self.rb3 = ResBlock(128) self.det3 = DetBlock(64) self.relu_conv17 = nn.ReLU() self.conv18 = nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=2, padding=0) # downsample by 2 self.rb4 = ResBlock(128) self.det4 = DetBlock(128) self.relu_conv20 = nn.ReLU() self.det5 = DetBlock(128)
def __init__(self, mode='slim'): super(ULFG, self).__init__() self.mode = mode self.base_channel = 8 * 2 self.backbone = nn.Sequential( _conv_bn(3, self.base_channel, 2), # 160*120 _conv_dw(self.base_channel, self.base_channel * 2, 1), _conv_dw(self.base_channel * 2, self.base_channel * 2, 2), # 80*60 _conv_dw(self.base_channel * 2, self.base_channel * 2, 1), _conv_dw(self.base_channel * 2, self.base_channel * 4, 2), # 40*30 _conv_dw(self.base_channel * 4, self.base_channel * 4, 1), _conv_dw(self.base_channel * 4, self.base_channel * 4, 1), _conv_dw(self.base_channel * 4, self.base_channel * 4, 1), _conv_dw(self.base_channel * 4, self.base_channel * 8, 2), # 20*15 _conv_dw(self.base_channel * 8, self.base_channel * 8, 1), _conv_dw(self.base_channel * 8, self.base_channel * 8, 1), _conv_dw(self.base_channel * 8, self.base_channel * 16, 2), # 10*8 _conv_dw(self.base_channel * 16, self.base_channel * 16, 1) ) if self.mode == 'rfb': self.backbone[7] = BasicRFB(self.base_channel * 4, self.base_channel * 4, stride=1, scale=1.0) self.source_layer_indexes = [8, 11, 13] self.extras = nn.Sequential( nn.Conv2d(in_channels=self.base_channel * 16, out_channels=self.base_channel * 4, kernel_size=1), nn.ReLU(), _seperable_conv2d(in_channels=self.base_channel * 4, out_channels=self.base_channel * 16, kernel_size=3, stride=2, padding=1), nn.ReLU() ) self.regression_headers = nn.ModuleList([ _seperable_conv2d(in_channels=self.base_channel * 4, out_channels=3 * 4, kernel_size=3, padding=1), _seperable_conv2d(in_channels=self.base_channel * 8, out_channels=2 * 4, kernel_size=3, padding=1), _seperable_conv2d(in_channels=self.base_channel * 16, out_channels=2 * 4, kernel_size=3, padding=1), nn.Conv2d(in_channels=self.base_channel * 16, out_channels=3 * 4, kernel_size=3, padding=1) ]) self.classification_headers = nn.ModuleList([ _seperable_conv2d(in_channels=self.base_channel * 4, out_channels=3 * 2, kernel_size=3, padding=1), _seperable_conv2d(in_channels=self.base_channel * 8, out_channels=2 * 2, kernel_size=3, padding=1), _seperable_conv2d(in_channels=self.base_channel * 16, out_channels=2 * 2, kernel_size=3, padding=1), nn.Conv2d(in_channels=self.base_channel * 16, out_channels=3 * 2, kernel_size=3, padding=1) ]) self.softmax = nn.Softmax(dim=2)
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), nn.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 make_layers(cfg, batch_norm=False): layers = [] in_channels = 3 for v in cfg: if v == 'M': layers += [nn.MaxPool2d(kernel_size=2, stride=2)] else: conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1) if batch_norm: layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)] else: layers += [conv2d, nn.ReLU(inplace=True)] in_channels = v return nn.Sequential(*layers)
def __init__(self): super(MobileNetV1, self).__init__() self.stage1 = nn.Sequential( conv_bn(3, 8, 2, leaky=0.1), # 3 conv_dw(8, 16, 1), # 7 conv_dw(16, 32, 2), # 11 conv_dw(32, 32, 1), # 19 conv_dw(32, 64, 2), # 27 conv_dw(64, 64, 1), # 43 ) self.stage2 = nn.Sequential( conv_dw(64, 128, 2), # 43 + 16 = 59 conv_dw(128, 128, 1), # 59 + 32 = 91 conv_dw(128, 128, 1), # 91 + 32 = 123 conv_dw(128, 128, 1), # 123 + 32 = 155 conv_dw(128, 128, 1), # 155 + 32 = 187 conv_dw(128, 128, 1), # 187 + 32 = 219 ) self.stage3 = nn.Sequential( conv_dw(128, 256, 2), # 219 +3 2 = 241 conv_dw(256, 256, 1), # 241 + 64 = 301 ) # self.avg = nn.AdaptiveAvgPool2d((1,1)) self.fc = nn.Linear(256, 1000)
def upsample(in_channels, out_channels): # should use F.inpterpolate return nn.Sequential( nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=(3, 3), stride=1, padding=1, groups=in_channels, bias=False), nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1, padding=0, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU())
def __init__(self, inp, oup, stride, expand_ratio, model_type=32): super(InvertedResidual_dwc, self).__init__() self.stride = stride assert stride in [1, 2] hidden_dim = int(round(inp * expand_ratio)) self.use_res_connect = self.stride == 1 and inp == oup self.conv = [] if expand_ratio == 1: self.conv.append( nn.Conv2d(inp, hidden_dim, kernel_size=(3, 3), stride=stride, padding=1, groups=hidden_dim)) self.conv.append(nn.BatchNorm2d(hidden_dim)) self.conv.append(nn.PReLU()) self.conv.append(nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False)) self.conv.append(nn.BatchNorm2d(oup)) if model_type == 32: self.conv.append(nn.PReLU()) else: self.conv.append(nn.Conv2d(inp, hidden_dim, 1, 1, 0, bias=False)) self.conv.append(nn.BatchNorm2d(hidden_dim)) self.conv.append(nn.PReLU()) self.conv.append( nn.Conv2d(hidden_dim, hidden_dim, kernel_size=(3, 3), stride=stride, padding=1, groups=hidden_dim)) self.conv.append(nn.BatchNorm2d(hidden_dim)) self.conv.append(nn.PReLU()) self.conv.append(nn.Conv2d(hidden_dim, oup, 1, 1, 0, bias=False)) self.conv.append(nn.BatchNorm2d(oup)) if model_type == 32: self.conv.append(nn.PReLU()) self.conv = nn.Sequential(*self.conv) if self.use_res_connect: self.eltadd = nn.EltAdd()
def __init__(self, channels, det_out=False): super(ResBlock, self).__init__() self.channels = channels self.det_out = det_out self.relu = nn.ReLU() self.block = nn.Sequential( nn.Conv2d(in_channels=self.channels, out_channels=self.channels, kernel_size=3, stride=1, padding=1), nn.ReLU(), nn.Conv2d(in_channels=self.channels, out_channels=self.channels, kernel_size=3, stride=1, padding=1)) self.eltadd = nn.EltAdd()
def build_conv_block(self, in_channels: int, out_channels: int, kernel_size: int = 3, stride: int = 1, padding: int = 1, dilation: int = 1, n_conv: int = 2, with_pool: bool = False): layers = [ nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation), nn.ReLU() ] for i in range(1, n_conv): layers += [ nn.Conv2d(out_channels, out_channels, kernel_size, stride, padding), nn.ReLU() ] if with_pool: layers += [nn.MaxPool2d(2, 2)] return nn.Sequential(*layers)
def conv_bn_no_relu(inp, oup, stride): return nn.Sequential( nn.Conv2d(inp, oup, 3, stride, 1, bias=False), nn.BatchNorm2d(oup), )
def conv_bn(inp, oup, stride, k_size=3): return nn.Sequential(nn.Conv2d(inp, oup, k_size, stride, 1, bias=False), nn.BatchNorm2d(oup), nn.PReLU())
def __init__(self, in_planes=256, out_planes=256): super(RFE, self).__init__() self.out_channels = out_planes self.inter_channels = int(in_planes / 4) self.branch0 = nn.Sequential( nn.Conv2d(in_planes, self.inter_channels, kernel_size=1, stride=1, padding=0), nn.ReLU(inplace=True), nn.Conv2d(self.inter_channels, self.inter_channels, kernel_size=(1, 5), stride=1, padding=(0, 2)), nn.ReLU(inplace=True), nn.Conv2d(self.inter_channels, self.inter_channels, kernel_size=1, stride=1, padding=0), nn.ReLU(inplace=True)) self.branch1 = nn.Sequential( nn.Conv2d(in_planes, self.inter_channels, kernel_size=1, stride=1, padding=0), nn.ReLU(inplace=True), nn.Conv2d(self.inter_channels, self.inter_channels, kernel_size=(5, 1), stride=1, padding=(2, 0)), nn.ReLU(inplace=True), nn.Conv2d(self.inter_channels, self.inter_channels, kernel_size=1, stride=1, padding=0), nn.ReLU(inplace=True)) self.branch2 = nn.Sequential( nn.Conv2d(in_planes, self.inter_channels, kernel_size=1, stride=1, padding=0), nn.ReLU(inplace=True), nn.Conv2d(self.inter_channels, self.inter_channels, kernel_size=(1, 3), stride=1, padding=(0, 1)), nn.ReLU(inplace=True), nn.Conv2d(self.inter_channels, self.inter_channels, kernel_size=1, stride=1, padding=0), nn.ReLU(inplace=True)) self.branch3 = nn.Sequential( nn.Conv2d(in_planes, self.inter_channels, kernel_size=1, stride=1, padding=0), nn.ReLU(inplace=True), nn.Conv2d(self.inter_channels, self.inter_channels, kernel_size=(3, 1), stride=1, padding=(1, 0)), nn.ReLU(inplace=True), nn.Conv2d(self.inter_channels, self.inter_channels, kernel_size=1, stride=1, padding=0), nn.ReLU(inplace=True)) self.cated_conv = nn.Sequential( nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=1, padding=0), nn.ReLU(inplace=True)) self.eltadd = nn.EltAdd()
def __init__(self): super(DSFD, self).__init__() self.size = 640 self.num_classes = 2 ###### # build backbone ###### resnet152 = vision.models.resnet152() self.layer1 = nn.Sequential(resnet152.conv1, resnet152.bn1, resnet152.relu, resnet152.maxpool, resnet152.layer1) self.layer2 = nn.Sequential(resnet152.layer2) self.layer3 = nn.Sequential(resnet152.layer3) self.layer4 = nn.Sequential(resnet152.layer4) self.layer5 = nn.Sequential(*[ nn.Conv2d(2048, 512, kernel_size=1), nn.BatchNorm2d(512), nn.ReLU(inplace=True), nn.Conv2d(512, 512, kernel_size=3, padding=1, stride=2), nn.BatchNorm2d(512), nn.ReLU(inplace=True) ]) self.layer6 = nn.Sequential(*[ nn.Conv2d( 512, 128, kernel_size=1, ), nn.BatchNorm2d(128), nn.ReLU(inplace=True), nn.Conv2d(128, 256, kernel_size=3, padding=1, stride=2), nn.BatchNorm2d(256), nn.ReLU(inplace=True) ]) ###### # dsfd specific layers ###### output_channels = [256, 512, 1024, 2048, 512, 256] # fpn fpn_in = output_channels self.latlayer3 = nn.Conv2d(fpn_in[3], fpn_in[2], kernel_size=1, stride=1, padding=0) self.latlayer2 = nn.Conv2d(fpn_in[2], fpn_in[1], kernel_size=1, stride=1, padding=0) self.latlayer1 = nn.Conv2d(fpn_in[1], fpn_in[0], kernel_size=1, stride=1, padding=0) self.smooth3 = nn.Conv2d(fpn_in[2], fpn_in[2], kernel_size=1, stride=1, padding=0) self.smooth2 = nn.Conv2d(fpn_in[1], fpn_in[1], kernel_size=1, stride=1, padding=0) self.smooth1 = nn.Conv2d(fpn_in[0], fpn_in[0], kernel_size=1, stride=1, padding=0) self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False) self.eltmul = nn.EltMul() # fem cpm_in = output_channels self.cpm3_3 = FEM(cpm_in[0]) self.cpm4_3 = FEM(cpm_in[1]) self.cpm5_3 = FEM(cpm_in[2]) self.cpm7 = FEM(cpm_in[3]) self.cpm6_2 = FEM(cpm_in[4]) self.cpm7_2 = FEM(cpm_in[5]) # pa cfg_mbox = [1, 1, 1, 1, 1, 1] head = pa_multibox(output_channels, cfg_mbox, self.num_classes) # detection head self.loc = nn.ModuleList(head[0]) self.conf = nn.ModuleList(head[1]) self.softmax = nn.Softmax(dim=-1)
def conv_1x1_bn(inp, oup): return nn.Sequential(nn.Conv2d(inp, oup, 1, 1, 0, bias=False), nn.BatchNorm2d(oup), nn.PReLU())
def __init__(self, embedding_size=128, input_size=224, width_mult=1., model_type=32): super(MobileNetV2, self).__init__() block_dwc = InvertedResidual_dwc input_channel = 64 last_channel = 256 interverted_residual_setting = [ # t, c, n, s [1, 32, 1, 1], # depthwise conv for first row [2, 32, 2, 1], [4, 32, 2, 1], [2, 32, 2, 2], [4, 32, 5, 1], [2, 32, 2, 2], [2, 32, 6, 2], ] if model_type != 32: for idx, irs in enumerate(interverted_residual_setting): irs[1] = model_type if idx == 2: irs[3] = 2 if idx == 3: irs[3] = 1 # building first layer input_channel = int(input_channel * width_mult) self.last_channel = int( last_channel * width_mult) if width_mult > 1.0 else last_channel self.features = [conv_bn(3, input_channel, 2)] # building inverted residual cnt = 0 for t, c, n, s in interverted_residual_setting: output_channel = int(c * width_mult) for i in range(n): if cnt > 1: if i == n - 1: # reduce the featuremap in the last. self.features.append( block_dwc(input_channel, output_channel, s, expand_ratio=t, model_type=model_type)) else: self.features.append( block_dwc(input_channel, output_channel, 1, expand_ratio=t, model_type=model_type)) input_channel = output_channel else: if i == n - 1: # reduce the featuremap in the last. self.features.append( block_dwc(input_channel, output_channel, s, expand_ratio=t, model_type=model_type)) else: self.features.append( block_dwc(input_channel, output_channel, 1, expand_ratio=t, model_type=model_type)) input_channel = output_channel cnt += 1 # building last several layers self.features.append(gated_conv1x1(input_channel, self.last_channel)) # make it nn.Sequential self.features_sequential = nn.Sequential(*self.features)
def __init__(self): super(SRN, self).__init__() block = Bottleneck layers = [3, 4, 6, 3] self.inplanes = 64 self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=2) self.layer5 = nn.Conv2d(2048, 1024, kernel_size=3, stride=2, padding=1) self.layer6 = nn.Conv2d(1024, 256, kernel_size=3, stride=2, padding=1) self.c5_lateral = nn.Conv2d(2048, 256, kernel_size=1, stride=1, padding=0) self.c4_lateral = nn.Conv2d(1024, 256, kernel_size=1, stride=1, padding=0) self.c3_lateral = nn.Conv2d(512, 256, kernel_size=1, stride=1, padding=0) self.c2_lateral = nn.Conv2d(256, 256, kernel_size=1, stride=1, padding=0) self.eltadd = nn.EltAdd() self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False) self.p7_conv = nn.Conv2d(256, 256, kernel_size=3, stride=2, padding=1) self.p6_conv = nn.Conv2d(256, 256, kernel_size=3, stride=2, padding=1) self.p5_conv = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) self.p4_conv = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) self.p3_conv = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) self.p2_conv = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) self.c7_conv = nn.Conv2d(256, 256, kernel_size=1, stride=1, padding=0) self.c6_conv = nn.Conv2d(1024, 256, kernel_size=1, stride=1, padding=0) self.c5_conv = nn.Conv2d(2048, 256, kernel_size=1, stride=1, padding=0) self.c4_conv = nn.Conv2d(1024, 256, kernel_size=1, stride=1, padding=0) self.c3_conv = nn.Conv2d(512, 256, kernel_size=1, stride=1, padding=0) self.c2_conv = nn.Conv2d(256, 256, kernel_size=1, stride=1, padding=0) # subnet_first stage num_anchors = 2 * 1 self.cls_subnet = nn.Sequential( nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), RFE(256, 256), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), ) self.box_subnet = nn.Sequential( nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), RFE(256, 256), nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1), nn.ReLU(inplace=True), ) self.cls_subnet_pred = nn.Conv2d(256, num_anchors * 1, kernel_size=1, stride=1, padding=0) self.box_subnet_pred = nn.Conv2d(256, num_anchors * 4, kernel_size=1, stride=1, padding=0) self.sigmoid = nn.Sigmoid()
def conv_bn(inp, oup, stride=1, leaky=0): return nn.Sequential(nn.Conv2d(inp, oup, 3, stride, 1, bias=False), nn.BatchNorm2d(oup), nn.LeakyReLU(negative_slope=leaky, inplace=True))
def _conv_bn(in_channels, out_channels, stride): return nn.Sequential( nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=3, stride=stride, padding=1, bias=False), nn.BatchNorm2d(num_features=out_channels), nn.ReLU(inplace=True) )
def _seperable_conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0): return nn.Sequential( nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=kernel_size, groups=in_channels, stride=stride, padding=padding), nn.ReLU(), nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1) )