def __init__(self, depth, k, num_classes=10, depthwise=True):
super().__init__()
num_blocks = (depth - 4) // 6
self.stem = 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,
depthwise=depthwise)
self.layer2 = self._make_layer(self.stages[1] * k,
self.stages[2] * k,
num_blocks,
stride=2,
depthwise=depthwise)
self.layer3 = self._make_layer(self.stages[2] * k,
self.stages[3] * k,
num_blocks,
stride=2,
depthwise=depthwise)
self.norm = Norm(self.stages[3] * k)
self.act = Act()
self.avgpool = GlobalAvgPool()
self.fc = Linear(self.stages[3] * k, num_classes)
def __init__(self, C, layers, auxiliary, drop_path, num_classes, genotype):
super().__init__()
self._num_layers = layers
self._auxiliary = auxiliary
self._drop_path = drop_path
stem_multiplier = 3
C_curr = stem_multiplier * C
self.stem = Conv2d(3, C_curr, 3, norm='def')
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
cell = Cell(genotype, C_prev_prev, C_prev, C_curr, reduction,
reduction_prev, drop_path)
reduction_prev = reduction
self.cells.append(cell)
C_prev_prev, C_prev = C_prev, cell.multiplier * C_curr
if auxiliary and i == 2 * layers // 3:
C_to_auxiliary = C_prev
if auxiliary:
self.auxiliary_head = AuxiliaryHeadCIFAR(C_to_auxiliary,
num_classes)
self.classifier = nn.Sequential(
GlobalAvgPool(),
Linear(C_prev, num_classes),
)
def __init__(self, depth, group_channels=(64, 128, 256), cardinality=(8, 8, 8),
num_classes=100, stages=(64, 64, 128, 256)):
super().__init__()
self.stages = stages
block = Bottleneck
layers = [(depth - 2) // 9] * 3
if isinstance(group_channels, int):
group_channels = [group_channels] * 3
if isinstance(cardinality, int):
cardinality = [cardinality] * 3
self.stem = Conv2d(3, self.stages[0], kernel_size=3, norm='def', act='def')
self.in_channels = self.stages[0]
self.layer1 = self._make_layer(
block, self.stages[1], layers[0], stride=1,
group_channels=group_channels[0], cardinality=cardinality[0])
self.layer2 = self._make_layer(
block, self.stages[2], layers[1], stride=2,
group_channels=group_channels[1], cardinality=cardinality[1])
self.layer3 = self._make_layer(
block, self.stages[3], layers[2], stride=2,
group_channels=group_channels[2], cardinality=cardinality[2])
self.avgpool = GlobalAvgPool()
self.fc = Linear(self.in_channels, num_classes)
def __init__(self, in_channels=1, num_classes=10, dropout=None):
super().__init__()
self.features = nn.Sequential(
Conv2d(in_channels, 6, 5, stride=1, padding=0, act='def'),
nn.MaxPool2d(2, 2),
Conv2d(6, 16, 5, stride=1, padding=0, act='def'),
nn.MaxPool2d(2, 2),
)
classifier = [
Flatten(),
Linear(400, 120, act='def'),
Linear(120, 84, act='def'),
Linear(84, num_classes)
]
if dropout:
classifier.insert(0, nn.Dropout(dropout))
classifier.insert(2, nn.Dropout(dropout))
classifier.insert(4, nn.Dropout(dropout))
self.classifier = nn.Sequential(*classifier)
def __init__(self, C, num_classes):
"""assuming input size 8x8"""
super().__init__()
self.features = nn.Sequential(
Act('relu', inplace=True),
Pool2d(5, stride=3, padding=0, type='avg'),
Conv2d(C, 128, 1, norm='def', act='relu'),
Conv2d(128, 768, 2, norm='def', act='relu', padding=0),
)
self.classifier = nn.Sequential(
GlobalAvgPool(),
Linear(768, num_classes),
)
def __init__(self,
depth,
block='basic',
dropout=0,
drop_path=0,
num_classes=10,
stages=(64, 64, 128, 256)):
super().__init__()
self.stages = stages
if block == 'basic':
block = BasicBlock
layers = [(depth - 2) // 6] * 3
else:
block = Bottleneck
layers = [(depth - 2) // 9] * 3
self.conv = Conv2d(3,
self.stages[0],
kernel_size=3,
norm='def',
act='def')
self.in_channels = self.stages[0]
self.layer1 = self._make_layer(block,
self.stages[1],
layers[0],
stride=1,
dropout=dropout,
drop_path=drop_path)
self.layer2 = self._make_layer(block,
self.stages[2],
layers[1],
stride=2,
dropout=dropout,
drop_path=drop_path)
self.layer3 = self._make_layer(block,
self.stages[3],
layers[2],
stride=2,
dropout=dropout,
drop_path=drop_path)
self.avgpool = GlobalAvgPool()
self.fc = Linear(self.in_channels, num_classes)
def __init__(self,
depth,
k,
num_classes=10,
dropout=0,
use_se=False,
drop_path=0,
depthwise=True):
super().__init__()
num_blocks = (depth - 4) // 6
self.stem = 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,
dropout=dropout,
use_se=use_se,
drop_path=drop_path,
depthwise=depthwise)
self.layer2 = self._make_layer(self.stages[1] * k,
self.stages[2] * k,
num_blocks,
stride=2,
dropout=dropout,
use_se=use_se,
drop_path=drop_path,
depthwise=depthwise)
self.layer3 = self._make_layer(self.stages[2] * k,
self.stages[3] * k,
num_blocks,
stride=2,
dropout=dropout,
use_se=use_se,
drop_path=drop_path,
depthwise=depthwise)
self.post_activ = nn.Sequential(Norm(self.stages[3] * k), Act())
self.classifier = nn.Sequential(
GlobalAvgPool(),
Linear(self.stages[3] * k, num_classes),
)
def __init__(self,
depth,
block='basic',
erase_relu=False,
num_classes=10,
stages=(16, 16, 32, 64)):
super().__init__()
self.stages = stages
if block == 'basic':
block = BasicBlock
layers = [(depth - 2) // 6] * 3
else:
block = Bottleneck
layers = [(depth - 2) // 9] * 3
self.stem = Conv2d(3,
self.stages[0],
kernel_size=3,
norm='def',
act='def')
self.in_channels = self.stages[0]
self.layer1 = self._make_layer(block,
self.stages[1],
layers[0],
stride=1,
erase_relu=erase_relu)
self.layer2 = self._make_layer(block,
self.stages[2],
layers[1],
stride=2,
erase_relu=erase_relu)
self.layer3 = self._make_layer(block,
self.stages[3],
layers[2],
stride=2,
erase_relu=erase_relu)
self.avgpool = GlobalAvgPool()
self.fc = Linear(self.in_channels, num_classes)
def __init__(self,
depth,
cardinality,
base_width,
num_classes=10,
stages=(64, 64, 128, 256)):
super().__init__()
self.stages = stages
block = Bottleneck
layers = [(depth - 2) // 9] * 3
self.stem = Conv2d(3,
self.stages[0],
kernel_size=3,
norm='def',
act='def')
self.in_channels = self.stages[0]
self.layer1 = self._make_layer(block,
self.stages[1],
layers[0],
stride=1,
cardinality=cardinality,
base_width=base_width)
self.layer2 = self._make_layer(block,
self.stages[2],
layers[1],
stride=2,
cardinality=cardinality,
base_width=base_width)
self.layer3 = self._make_layer(block,
self.stages[3],
layers[2],
stride=2,
cardinality=cardinality,
base_width=base_width)
self.avgpool = GlobalAvgPool()
self.fc = Linear(self.in_channels, num_classes)