def __init__(self, block, layers, num_classes=1000, in_chans=3,
cardinality=1, base_width=64,
drop_rate=0.0, block_drop_rate=0.0,
global_pool='avg'):
self.num_classes = num_classes
self.inplanes = 64
self.cardinality = cardinality
self.base_width = base_width
self.drop_rate = drop_rate
self.expansion = block.expansion
super(ResNet, self).__init__()
self.conv1 = nn.Conv2d(in_chans, 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], drop_rate=block_drop_rate)
self.layer2 = self._make_layer(block, 128, layers[1], stride=2, drop_rate=block_drop_rate)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2, drop_rate=block_drop_rate)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2, drop_rate=block_drop_rate)
self.global_pool = SelectAdaptivePool2d(pool_type=global_pool)
self.num_features = 512 * block.expansion
self.fc = nn.Linear(self.num_features * self.global_pool.feat_mult(), num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1.)
nn.init.constant_(m.bias, 0.)
def reset_classifier(self, num_classes, global_pool='avg'):
self.global_pool = SelectAdaptivePool2d(pool_type=global_pool)
self.num_classes = num_classes
del self.fc
if num_classes:
self.fc = nn.Linear(self.num_features * self.global_pool.feat_mult(), num_classes)
else:
self.fc = None
def __init__(self, num_classes=1001, in_chans=3, drop_rate=0.5, global_pool='avg'):
super(PNASNet5Large, self).__init__()
self.num_classes = num_classes
self.num_features = 4320
self.drop_rate = drop_rate
self.conv_0 = nn.Sequential(OrderedDict([
('conv', nn.Conv2d(in_chans, 96, kernel_size=3, stride=2, bias=False)),
('bn', nn.BatchNorm2d(96, eps=0.001))
]))
self.cell_stem_0 = CellStem0(in_channels_left=96, out_channels_left=54,
in_channels_right=96,
out_channels_right=54)
self.cell_stem_1 = Cell(in_channels_left=96, out_channels_left=108,
in_channels_right=270, out_channels_right=108,
match_prev_layer_dimensions=True,
is_reduction=True)
self.cell_0 = Cell(in_channels_left=270, out_channels_left=216,
in_channels_right=540, out_channels_right=216,
match_prev_layer_dimensions=True)
self.cell_1 = Cell(in_channels_left=540, out_channels_left=216,
in_channels_right=1080, out_channels_right=216)
self.cell_2 = Cell(in_channels_left=1080, out_channels_left=216,
in_channels_right=1080, out_channels_right=216)
self.cell_3 = Cell(in_channels_left=1080, out_channels_left=216,
in_channels_right=1080, out_channels_right=216)
self.cell_4 = Cell(in_channels_left=1080, out_channels_left=432,
in_channels_right=1080, out_channels_right=432,
is_reduction=True, zero_pad=True)
self.cell_5 = Cell(in_channels_left=1080, out_channels_left=432,
in_channels_right=2160, out_channels_right=432,
match_prev_layer_dimensions=True)
self.cell_6 = Cell(in_channels_left=2160, out_channels_left=432,
in_channels_right=2160, out_channels_right=432)
self.cell_7 = Cell(in_channels_left=2160, out_channels_left=432,
in_channels_right=2160, out_channels_right=432)
self.cell_8 = Cell(in_channels_left=2160, out_channels_left=864,
in_channels_right=2160, out_channels_right=864,
is_reduction=True)
self.cell_9 = Cell(in_channels_left=2160, out_channels_left=864,
in_channels_right=4320, out_channels_right=864,
match_prev_layer_dimensions=True)
self.cell_10 = Cell(in_channels_left=4320, out_channels_left=864,
in_channels_right=4320, out_channels_right=864)
self.cell_11 = Cell(in_channels_left=4320, out_channels_left=864,
in_channels_right=4320, out_channels_right=864)
self.relu = nn.ReLU()
self.global_pool = SelectAdaptivePool2d(pool_type=global_pool)
self.last_linear = nn.Linear(self.num_features * self.global_pool.feat_mult(), num_classes)
def __init__(self,
block,
layers,
groups,
reduction,
drop_rate=0.2,
in_chans=3,
inplanes=128,
input_3x3=True,
downsample_kernel_size=3,
downsample_padding=1,
num_classes=1000,
global_pool='avg'):
"""
Parameters
----------
block (nn.Module): Bottleneck class.
- For SENet154: SEBottleneck
- For SE-ResNet models: SEResNetBottleneck
- For SE-ResNeXt models: SEResNeXtBottleneck
layers (list of ints): Number of residual blocks for 4 layers of the
network (layer1...layer4).
groups (int): Number of groups for the 3x3 convolution in each
bottleneck block.
- For SENet154: 64
- For SE-ResNet models: 1
- For SE-ResNeXt models: 32
reduction (int): Reduction ratio for Squeeze-and-Excitation modules.
- For all models: 16
dropout_p (float or None): Drop probability for the Dropout layer.
If `None` the Dropout layer is not used.
- For SENet154: 0.2
- For SE-ResNet models: None
- For SE-ResNeXt models: None
inplanes (int): Number of input channels for layer1.
- For SENet154: 128
- For SE-ResNet models: 64
- For SE-ResNeXt models: 64
input_3x3 (bool): If `True`, use three 3x3 convolutions instead of
a single 7x7 convolution in layer0.
- For SENet154: True
- For SE-ResNet models: False
- For SE-ResNeXt models: False
downsample_kernel_size (int): Kernel size for downsampling convolutions
in layer2, layer3 and layer4.
- For SENet154: 3
- For SE-ResNet models: 1
- For SE-ResNeXt models: 1
downsample_padding (int): Padding for downsampling convolutions in
layer2, layer3 and layer4.
- For SENet154: 1
- For SE-ResNet models: 0
- For SE-ResNeXt models: 0
num_classes (int): Number of outputs in `last_linear` layer.
- For all models: 1000
"""
super(SENet, self).__init__()
self.inplanes = inplanes
self.num_classes = num_classes
if input_3x3:
layer0_modules = [
('conv1',
nn.Conv2d(in_chans, 64, 3, stride=2, padding=1, bias=False)),
('bn1', nn.BatchNorm2d(64)),
('relu1', nn.ReLU(inplace=True)),
('conv2', nn.Conv2d(64, 64, 3, stride=1, padding=1,
bias=False)),
('bn2', nn.BatchNorm2d(64)),
('relu2', nn.ReLU(inplace=True)),
('conv3',
nn.Conv2d(64, inplanes, 3, stride=1, padding=1, bias=False)),
('bn3', nn.BatchNorm2d(inplanes)),
('relu3', nn.ReLU(inplace=True)),
]
else:
layer0_modules = [
('conv1',
nn.Conv2d(in_chans,
inplanes,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('bn1', nn.BatchNorm2d(inplanes)),
('relu1', nn.ReLU(inplace=True)),
]
# To preserve compatibility with Caffe weights `ceil_mode=True`
# is used instead of `padding=1`.
layer0_modules.append(('pool', nn.MaxPool2d(3,
stride=2,
ceil_mode=True)))
self.layer0 = nn.Sequential(OrderedDict(layer0_modules))
self.layer1 = self._make_layer(block,
planes=64,
blocks=layers[0],
groups=groups,
reduction=reduction,
downsample_kernel_size=1,
downsample_padding=0)
self.layer2 = self._make_layer(
block,
planes=128,
blocks=layers[1],
stride=2,
groups=groups,
reduction=reduction,
downsample_kernel_size=downsample_kernel_size,
downsample_padding=downsample_padding)
self.layer3 = self._make_layer(
block,
planes=256,
blocks=layers[2],
stride=2,
groups=groups,
reduction=reduction,
downsample_kernel_size=downsample_kernel_size,
downsample_padding=downsample_padding)
self.layer4 = self._make_layer(
block,
planes=512,
blocks=layers[3],
stride=2,
groups=groups,
reduction=reduction,
downsample_kernel_size=downsample_kernel_size,
downsample_padding=downsample_padding)
self.avg_pool = SelectAdaptivePool2d(pool_type=global_pool)
self.drop_rate = drop_rate
self.num_features = 512 * block.expansion
self.last_linear = nn.Linear(self.num_features, num_classes)
for m in self.modules():
_weight_init(m)
def __init__(self,
block,
layers,
num_classes=1000,
in_chans=3,
use_se=False,
cardinality=1,
base_width=64,
stem_width=64,
deep_stem=False,
block_reduce_first=1,
down_kernel_size=1,
avg_down=False,
dilated=False,
norm_layer=nn.BatchNorm2d,
drop_rate=0.0,
global_pool='avg'):
self.num_classes = num_classes
self.inplanes = stem_width * 2 if deep_stem else 64
self.cardinality = cardinality
self.base_width = base_width
self.drop_rate = drop_rate
self.expansion = block.expansion
self.dilated = dilated
super(GluonResNet, self).__init__()
if not deep_stem:
self.conv1 = nn.Conv2d(in_chans,
stem_width,
kernel_size=7,
stride=2,
padding=3,
bias=False)
else:
conv1_modules = [
nn.Conv2d(in_chans,
stem_width,
3,
stride=2,
padding=1,
bias=False),
norm_layer(stem_width),
nn.ReLU(),
nn.Conv2d(stem_width,
stem_width,
3,
stride=1,
padding=1,
bias=False),
norm_layer(stem_width),
nn.ReLU(),
nn.Conv2d(stem_width,
self.inplanes,
3,
stride=1,
padding=1,
bias=False),
]
self.conv1 = nn.Sequential(*conv1_modules)
self.bn1 = norm_layer(self.inplanes)
self.relu = nn.ReLU()
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
stride_3_4 = 1 if self.dilated else 2
dilation_3 = 2 if self.dilated else 1
dilation_4 = 4 if self.dilated else 1
self.layer1 = self._make_layer(block,
64,
layers[0],
stride=1,
reduce_first=block_reduce_first,
use_se=use_se,
avg_down=avg_down,
down_kernel_size=1,
norm_layer=norm_layer)
self.layer2 = self._make_layer(block,
128,
layers[1],
stride=2,
reduce_first=block_reduce_first,
use_se=use_se,
avg_down=avg_down,
down_kernel_size=down_kernel_size,
norm_layer=norm_layer)
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=stride_3_4,
dilation=dilation_3,
reduce_first=block_reduce_first,
use_se=use_se,
avg_down=avg_down,
down_kernel_size=down_kernel_size,
norm_layer=norm_layer)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=stride_3_4,
dilation=dilation_4,
reduce_first=block_reduce_first,
use_se=use_se,
avg_down=avg_down,
down_kernel_size=down_kernel_size,
norm_layer=norm_layer)
self.global_pool = SelectAdaptivePool2d(pool_type=global_pool)
self.num_features = 512 * block.expansion
self.fc = nn.Linear(self.num_features * self.global_pool.feat_mult(),
num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight,
mode='fan_out',
nonlinearity='relu')
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1.)
nn.init.constant_(m.bias, 0.)
def __init__(self,
block_args,
num_classes=1000,
in_chans=3,
stem_size=32,
num_features=1280,
depth_multiplier=1.0,
depth_divisor=8,
min_depth=None,
bn_momentum=_BN_MOMENTUM_PT_DEFAULT,
bn_eps=_BN_EPS_PT_DEFAULT,
drop_rate=0.,
act_fn=F.relu,
se_gate_fn=torch.sigmoid,
se_reduce_mid=False,
global_pool='avg',
head_conv='default',
weight_init='goog',
folded_bn=False,
padding_same=False):
super(GenMobileNet, self).__init__()
self.num_classes = num_classes
self.depth_multiplier = depth_multiplier
self.drop_rate = drop_rate
self.act_fn = act_fn
self.num_features = num_features
stem_size = _round_channels(stem_size, depth_multiplier, depth_divisor,
min_depth)
self.conv_stem = sconv2d(in_chans,
stem_size,
3,
padding=_padding_arg(1, padding_same),
stride=2,
bias=folded_bn)
self.bn1 = None if folded_bn else nn.BatchNorm2d(
stem_size, momentum=bn_momentum, eps=bn_eps)
in_chs = stem_size
builder = _BlockBuilder(depth_multiplier, depth_divisor, min_depth,
act_fn, se_gate_fn, se_reduce_mid, bn_momentum,
bn_eps, folded_bn, padding_same)
self.blocks = nn.Sequential(*builder(in_chs, block_args))
in_chs = builder.in_chs
if not head_conv or head_conv == 'none':
self.efficient_head = False
self.conv_head = None
assert in_chs == self.num_features
else:
self.efficient_head = head_conv == 'efficient'
self.conv_head = sconv2d(in_chs,
self.num_features,
1,
padding=_padding_arg(0, padding_same),
bias=folded_bn
and not self.efficient_head)
self.bn2 = None if (folded_bn or self.efficient_head) else \
nn.BatchNorm2d(self.num_features, momentum=bn_momentum, eps=bn_eps)
self.global_pool = SelectAdaptivePool2d(pool_type=global_pool)
self.classifier = nn.Linear(self.num_features, self.num_classes)
for m in self.modules():
if weight_init == 'goog':
_initialize_weight_goog(m)
else:
_initialize_weight_default(m)