def __init__(self, num_anchors, num_classes, in_channels_list, focal_init=False, lite=False, large_kernel=False): super().__init__() self.num_classes = num_classes num_anchors = tuplify(num_anchors, len(in_channels_list)) kernel_size = 5 if (lite and large_kernel) else 3 self.loc_heads = nn.ModuleList([ nn.Sequential( get_norm_layer("default", c), Conv2d(c, n * 4, kernel_size=kernel_size, depthwise_separable=lite, mid_norm_layer='default')) for c, n in zip(in_channels_list, num_anchors) ]) self.cls_heads = nn.ModuleList([ nn.Sequential( get_norm_layer("default", c), Conv2d(c, n * num_classes, kernel_size=kernel_size, depthwise_separable=lite, mid_norm_layer='default')) for c, n in zip(in_channels_list, num_anchors) ]) if focal_init: for p in self.cls_heads: get_last_conv(p).bias.data.fill_(inverse_sigmoid(0.01))
def __init__(self, in_channels, out_channels, use_se, drop_path): super().__init__() self.bn1 = get_norm_layer(in_channels) self.nl1 = get_activation("default") self.conv1 = Conv2d(in_channels, out_channels, kernel_size=3) self.bn2 = get_norm_layer(out_channels) self.nl2 = get_activation("default") self.conv2 = Conv2d(out_channels, out_channels, kernel_size=3) if use_se: self.se = SEModule(out_channels, reduction=8) if drop_path: self.drop_path = DropPath(drop_path)
def __init__(self, in_channels, out_channels, stride=1): super().__init__() self.conv = nn.Sequential( get_norm_layer('default', in_channels), Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, bias=False), get_norm_layer('default', out_channels), get_activation('default'), Conv2d(out_channels, out_channels, kernel_size=3, bias=False), get_norm_layer('default', out_channels), ) self.shortcut = Shortcut(in_channels, out_channels, stride)
def __init__(self, in_channels, out_channels, stride, groups, use_se): super().__init__() self.use_se = use_se self.conv1 = Conv2d(in_channels, out_channels, kernel_size=1, norm_layer='default', activation='default') self.conv2 = Conv2d(out_channels, out_channels, kernel_size=3, stride=stride, groups=groups, norm_layer='default', activation='default') if self.use_se: self.se = SE(out_channels, 4) self.conv3 = Conv2d(out_channels, out_channels, kernel_size=1, norm_layer='default') if stride != 1 or in_channels != out_channels: layers = [] if stride != 1: layers.append(nn.AvgPool2d(kernel_size=(2, 2), stride=2)) layers.extend([ Conv2d(in_channels, out_channels, kernel_size=1, bias=False), get_norm_layer(out_channels), ]) self.shortcut = nn.Sequential(*layers) else: self.shortcut = nn.Identity() self.relu = get_activation('default')
def __init__(self, in_channels, channels, out_channels, kernel_size, stride=1, se_ratio=1 / 16): super().__init__() self.bn = get_norm_layer('default', in_channels) if in_channels != channels: self.expand = Conv2d(in_channels, channels, kernel_size=1, norm_layer='default', activation='default') self.dwconv = Conv2d(channels, channels, kernel_size, stride=stride, groups=channels, norm_layer='default', activation='default') if se_ratio: assert 0 < se_ratio < 1 self.se = SEModule(channels, reduction=int(1 / se_ratio)) if out_channels is not None: self.project = Conv2d(channels, out_channels, kernel_size=1, norm_layer='default') self.use_res_connect = stride == 1 and in_channels == out_channels
def __init__(self, primitives=PRIMITIVES, C=16, num_stacked=5, nodes=4, num_classes=10, tau=10.0): super().__init__() self.primitives = primitives self.C = C self.num_classes = num_classes self.num_stacked = num_stacked self.nodes = nodes self.tau = tau self.stem = Conv2d(3, C, kernel_size=3, norm_layer='default') for i in range(3): if i != 0: self.add_module("reduce%d" % i, ReductionCell(C, C * 2)) C = C * 2 stage = nn.ModuleList() for _ in range(num_stacked): stage.append(NormalCell(primitives, nodes, C)) self.add_module("stage%d" % (i + 1), stage) self.post_activ = nn.Sequential( get_norm_layer(C), get_activation(), ) self.avg_pool = nn.AdaptiveAvgPool2d(1) self.classifier = nn.Linear(C, num_classes) self._initialize_alphas()
def __init__(self, C_in, C_out): super().__init__() assert C_out % 2 == 0 self.relu = nn.ReLU(inplace=False) self.conv_1 = Conv2d(C_in, C_out // 2, 1, stride=2, bias=False) self.conv_2 = Conv2d(C_in, C_out // 2, 1, stride=2, bias=False) self.bn = get_norm_layer(C_out)
def __init__(self, depth, k, num_classes=10, use_se=False, drop_path=0): super().__init__() num_blocks = (depth - 4) // 6 self.conv = Conv2d(3, self.stages[0], kernel_size=3) self.layer1 = self._make_layer(self.stages[0] * 1, self.stages[1] * k, num_blocks, stride=1, use_se=use_se, drop_path=drop_path) self.layer2 = self._make_layer(self.stages[1] * k, self.stages[2] * k, num_blocks, stride=2, use_se=use_se, drop_path=drop_path) self.layer3 = self._make_layer(self.stages[2] * k, self.stages[3] * k, num_blocks, stride=2, use_se=use_se, drop_path=drop_path) self.bn = get_norm_layer(self.stages[3] * k) self.nl = get_activation('default') self.avgpool = nn.AdaptiveAvgPool2d(1) self.fc = nn.Linear(self.stages[3] * k, num_classes)
def __init__(self, C_in, C_out, kernel_size): super().__init__() self.op = nn.Sequential( get_activation(), Conv2d(C_in, C_out, kernel_size, bias=False), get_norm_layer(C_out), )
def __init__(self, start_channels, num_classes, block, widening_fractor, depth): super().__init__() if block == 'basic': block = BasicBlock num_layers = [(depth - 2) // 6] * 3 elif block == 'bottleneck': block = Bottleneck num_layers = [(depth - 2) // 9] * 3 else: raise ValueError("invalid block type: %s" % block) strides = [1, 2, 2] self.add_channel = widening_fractor / sum(num_layers) self.in_channels = start_channels self.channels = start_channels layers = [ Conv2d(3, start_channels, kernel_size=3, norm_layer='default') ] for n, s in zip(num_layers, strides): layers.append(self._make_layer(block, n, stride=s)) self.features = nn.Sequential(*layers) assert (start_channels + widening_fractor) * block.expansion == self.in_channels self.post_activ = nn.Sequential( get_norm_layer(self.in_channels), get_activation('default'), ) self.final_pool = nn.AdaptiveAvgPool2d(1) self.output = nn.Linear(self.in_channels, num_classes)
def __init__(self, primitives, C): super().__init__() self._ops = nn.ModuleList() for primitive in primitives: op = OPS[primitive](C, 1) if 'pool' in primitive: op = nn.Sequential(op, get_norm_layer(C)) self._ops.append(op)
def __init__(self, C, stride): super().__init__() self._ops = nn.ModuleList() for primitive in PRIMITIVES: op = OPS[primitive](C, stride) if 'pool' in primitive: op = nn.Sequential(op, get_norm_layer(C)) self._ops.append(op)
def __init__(self, in_channels, out_channels, kernel_size, stride=1): super(NasConv, self).__init__() self.activ = get_activation('default') self.conv = Conv2d(in_channels, out_channels, kernel_size, stride, bias=False) self.bn = get_norm_layer('default', out_channels)
def __init__(self, in_channels, out_channels, stride=1, use_se=False): super().__init__() self.use_se = use_se self.bn1 = get_norm_layer(in_channels) self.nl1 = get_activation("default") self.conv1 = Conv2d(in_channels, out_channels, kernel_size=3, stride=stride) self.bn2 = get_norm_layer(out_channels) self.nl2 = get_activation("default") self.conv2 = Conv2d(out_channels, out_channels, kernel_size=3) if self.use_se: self.se = SEModule(out_channels, reduction=8) self.shortcut = Conv2d(in_channels, out_channels, kernel_size=1, stride=stride)
def __init__(self, in_channels, channels, stride=1): super().__init__() out_channels = channels * self.expansion self.conv = nn.Sequential( get_norm_layer(in_channels), Conv2d(in_channels, channels, kernel_size=1, bias=False), get_norm_layer(channels), get_activation(), Conv2d(channels, channels, kernel_size=3, stride=stride, bias=False), get_norm_layer(channels), get_activation(), Conv2d(channels, out_channels, kernel_size=1, bias=False), get_norm_layer(out_channels), ) self.shortcut = Shortcut(in_channels, out_channels, stride)
def __init__(self, in_channels, out_channels, kernel_size, stride): super().__init__() self.activ = get_activation("default") self.conv = Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, bias=False, depthwise_separable=True) self.bn = get_norm_layer('bn', out_channels)
def __init__(self, in_channels, out_channels): super().__init__() mid_channels = out_channels // 2 self.activ = get_activation('default') self.path1 = NasPathBranch(in_channels=in_channels, out_channels=mid_channels) self.path2 = NasPathBranch(in_channels=in_channels, out_channels=mid_channels, extra_padding=True) self.bn = get_norm_layer('default', out_channels)
def __init__(self, stem_channels=64, mid_channels=(64, 80, 96, 112), out_channels=(128, 256, 384, 512), num_modules=(1, 1, 1, 1), num_classes=1000): super().__init__() num_stages = 5 assert len(mid_channels) == len(out_channels) == len( num_modules) == num_stages - 1 self.features = nn.Sequential() self.features.add_module( "init_block", nn.Sequential( Conv2d(3, stem_channels, kernel_size=3, stride=2, norm_layer='default', activation='default'), Conv2d(stem_channels, stem_channels, kernel_size=3, norm_layer='default', activation='default'), Conv2d(stem_channels, stem_channels * 2, kernel_size=3, norm_layer='default', activation='default'), )) in_channels = stem_channels * 2 for i, m, o, n in zip(range(num_stages - 1), mid_channels, out_channels, num_modules): stage = nn.Sequential() stage.add_module( "pool", nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)) for j in range(n): stage.add_module("unit%d" % (j + 1), OSA(in_channels, m, o)) in_channels = o self.features.add_module("stage%d" % (i + 1), stage) self.features.add_module( "post_activ", nn.Sequential( get_norm_layer("default", in_channels), get_activation("default"), )) self.features.add_module("final_pool", nn.AdaptiveAvgPool2d(1)) self.output = nn.Linear(in_features=in_channels, out_features=num_classes)
def __init__(self, C, layers, steps=4, multiplier=4, stem_multiplier=3, num_classes=10, tau=10.0): super().__init__() self.C = C self.num_classes = num_classes self.layers = layers self.steps = steps self.multiplier = multiplier self.tau = tau C_curr = stem_multiplier * C self.stem = nn.Sequential( Conv2d(3, C_curr, kernel_size=3, bias=False), get_norm_layer(C_curr), ) C_prev_prev, C_prev, C_curr = C_curr, C_curr, C self.cells = nn.ModuleList() reduction_prev = False for i in range(layers): if i in [layers // 3, 2 * layers // 3]: C_curr *= 2 reduction = True else: reduction = False if reduction: cell = ReductionCell(C_prev_prev, C_prev, C_curr) else: cell = NormalCell(steps, multiplier, C_prev_prev, C_prev, C_curr, reduction_prev) reduction_prev = reduction self.cells.append(cell) C_prev_prev, C_prev = C_prev, multiplier * C_curr self.post_activ = nn.Sequential( get_norm_layer(C_prev), get_activation(), ) self.avg_pool = nn.AdaptiveAvgPool2d(1) self.classifier = nn.Linear(C_prev, num_classes) self._initialize_alphas()
def __init__(self, C_prev_prev, C_prev, C): super().__init__() self.preprocess0 = ReLUConvBN(C_prev_prev, C, 1) self.preprocess1 = ReLUConvBN(C_prev, C, 1) self.branch_a1 = nn.Sequential( get_activation(), Conv2d(C, C, (1, 3), stride=(1, 2), groups=8, bias=False), Conv2d(C, C, (3, 1), stride=(2, 1), groups=8, bias=False), get_norm_layer(C, affine=True), get_activation(), Conv2d(C, C, 1), get_norm_layer(C, affine=True), ) self.branch_a2 = nn.Sequential( nn.MaxPool2d(3, stride=2, padding=1), get_norm_layer(C, affine=True) ) self.branch_b1 = nn.Sequential( get_activation(), Conv2d(C, C, (1, 3), stride=(1, 2), groups=8, bias=False), Conv2d(C, C, (3, 1), stride=(2, 1), groups=8, bias=False), get_norm_layer(C, affine=True), get_activation(), Conv2d(C, C, 1), get_norm_layer(C, affine=True), ) self.branch_b2 = nn.Sequential( nn.MaxPool2d(3, stride=2, padding=1), get_norm_layer(C, affine=True) )
def __init__(self, num_anchors, num_classes, in_channels_list, focal_init=False): super().__init__() self.num_classes = num_classes num_anchors = tuplify(num_anchors, len(in_channels_list)) self.loc_heads = nn.ModuleList([ nn.Sequential(get_norm_layer("default", c), Conv2d(c, n * 4, kernel_size=1)) for c, n in zip(in_channels_list, num_anchors) ]) self.cls_heads = nn.ModuleList([ nn.Sequential(get_norm_layer("default", c), Conv2d(c, n * num_classes, kernel_size=1)) for c, n in zip(in_channels_list, num_anchors) ]) if focal_init: for p in self.cls_heads: get_last_conv(p).bias.data.fill_(inverse_sigmoid(0.01))
def __init__(self, C_in, C_out, kernel_size, stride, padding): super().__init__() self.op = nn.Sequential( get_activation(), Conv2d(C_in, C_in, kernel_size=kernel_size, stride=stride, groups=C_in, bias=False), Conv2d(C_in, C_in, kernel_size=1, bias=False), get_norm_layer(C_in), get_activation(), nn.Conv2d(C_in, C_in, kernel_size=kernel_size, stride=1, padding=padding, groups=C_in, bias=False), nn.Conv2d(C_in, C_out, kernel_size=1, padding=0, bias=False), get_norm_layer(C_out), )
def __init__(self, C_in, C_out, kernel_size, stride, dilation): super().__init__() self.op = nn.Sequential( get_activation(), Conv2d(C_in, C_in, kernel_size=kernel_size, stride=stride, dilation=dilation, groups=C_in, bias=False), Conv2d(C_in, C_out, kernel_size=1, bias=False), get_norm_layer(C_out), )
def _make_head(self, num_layers, f_channels, out_channels): layers = [] for i in range(num_layers): layers.append( MBConv(f_channels, f_channels * self.expand_ratio, f_channels, kernel_size=5)) layers.append( nn.Sequential( get_norm_layer('default', f_channels), Conv2d(f_channels, out_channels, kernel_size=1), )) return nn.Sequential(*layers)
def __init__(self, num_anchors, num_classes, in_channels, lite=False, concat=True): super().__init__() self.num_classes = num_classes self.concat = concat num_anchors = _tuple(num_anchors, len(in_channels)) self.preds = nn.ModuleList([ nn.Sequential( get_norm_layer('default', c), Conv2d(c, n * (num_classes + 4), kernel_size=3, depthwise_separable=lite, mid_norm_layer='default') ) for c, n in zip(in_channels, num_anchors) ]) for p in self.preds: get_last_conv(p).bias.data[4:].fill_(inverse_sigmoid(0.01))
def __init__(self, start_channels, num_classes, block, widening_fractor, num_layers): super().__init__() self.add_channel = widening_fractor / sum(num_layers) self.in_channels = start_channels self.channels = start_channels self.features = nn.Sequential( Conv2d(3, start_channels, kernel_size=3, norm_layer='default'), self._make_layer(block, num_layers[0], stride=1), self._make_layer(block, num_layers[1], stride=2), self._make_layer(block, num_layers[2], stride=2), ) assert (start_channels + widening_fractor) * block.expansion == self.in_channels self.post_activ = nn.Sequential( get_norm_layer('default', self.in_channels), get_activation('default'), ) self.final_pool = nn.AdaptiveAvgPool2d(1) self.output = nn.Linear(self.in_channels, num_classes)
def __init__(self, stem_channels=64, mid_channels=192, growth_rate=48, num_units=(6, 8, 8, 8)): super().__init__() self.features = nn.Sequential() self.features.add_module("init_block", StemBlock(stem_channels)) in_channels = stem_channels * 2 for i, n in enumerate(num_units): stage = nn.Sequential() if i != len(num_units) - 1: stage.add_module("trans", Transition(in_channels, in_channels)) for j in range(n): stage.add_module("unit%d" % (j + 1), DenseUnit(in_channels, mid_channels, growth_rate)) in_channels += growth_rate self.features.add_module("stage%d" % (i + 1), stage) self.features.add_module("post_activ", seq( ("bn", get_norm_layer("default", in_channels)), ("relu", get_activation("default")), ))
def __init__(self, stem_channels=64, mid_channels=192, growth_rate=48, num_units=(6, 8, 8, 8)): super().__init__() self.init_block = StemBlock(stem_channels) in_channels = stem_channels * 2 out_channels = [in_channels] for i, n in enumerate(num_units): stage = nn.Sequential() stage.add_module("pool", nn.MaxPool2d(kernel_size=2, stride=2, ceil_mode=True)) for j in range(n): stage.add_module("unit%d" % (j + 1), DenseUnit(in_channels, mid_channels, growth_rate)) in_channels += growth_rate if i != len(num_units) - 1: stage.add_module( "trans", Transition(in_channels, in_channels)) out_channels.append(in_channels) self.add_module("stage%d" % (i + 1), stage) self.post_activ = seq( ("bn", get_norm_layer("default", in_channels)), ("relu", get_activation("default")), ) del self.stage4.pool self.trans = Transition(out_channels[-1], out_channels[-1]) self.proj = Transition(out_channels[-1], 512) self.extra1 = BasicBlock(512, 512) self.extra2 = BasicBlock(512, 256) self.extra3 = BasicBlock(256, 256) self.extra4 = BasicBlock(256, 256) self.out_channels = [out_channels[-3], 512, 512, 256, 256, 256]
'sep_conv_3x3': lambda C, stride: SepConv(C, C, 3, stride, 1), 'sep_conv_5x5': lambda C, stride: SepConv(C, C, 5, stride, 2), 'sep_conv_7x7': lambda C, stride: SepConv(C, C, 7, stride, 3), 'dil_conv_3x3': lambda C, stride: DilConv(C, C, 3, stride, 2), 'dil_conv_5x5': lambda C, stride: DilConv(C, C, 5, stride, 4), 'conv_7x1_1x7': lambda C, stride: nn.Sequential( get_activation(), Conv2d(C, C, (1, 7), stride=(1, stride), bias=False), Conv2d(C, C, (7, 1), stride=(stride, 1), bias=False), get_norm_layer(C), ), } class ReLUConvBN(nn.Module): def __init__(self, C_in, C_out, kernel_size): super().__init__() self.op = nn.Sequential( get_activation(), Conv2d(C_in, C_out, kernel_size, bias=False), get_norm_layer(C_out), ) def forward(self, x): return self.op(x)