You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1138 lines
49 KiB
1138 lines
49 KiB
"""PyTorch ResNet
|
|
|
|
This started as a copy of https://github.com/pytorch/vision 'resnet.py' (BSD-3-Clause) with
|
|
additional dropout and dynamic global avg/max pool.
|
|
|
|
ResNeXt, SE-ResNeXt, SENet, and MXNet Gluon stem/downsample variants, tiered stems added by Ross Wightman
|
|
Copyright 2020 Ross Wightman
|
|
"""
|
|
import math
|
|
import copy
|
|
|
|
import torch
|
|
import torch.nn as nn
|
|
import torch.nn.functional as F
|
|
|
|
from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
|
|
from .helpers import build_model_with_cfg
|
|
from .layers import SelectAdaptivePool2d, DropBlock2d, DropPath, AvgPool2dSame, create_attn, BlurPool2d
|
|
from .registry import register_model
|
|
|
|
__all__ = ['ResNet', 'BasicBlock', 'Bottleneck'] # model_registry will add each entrypoint fn to this
|
|
|
|
|
|
def _cfg(url='', **kwargs):
|
|
return {
|
|
'url': url,
|
|
'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': (7, 7),
|
|
'crop_pct': 0.875, 'interpolation': 'bilinear',
|
|
'mean': IMAGENET_DEFAULT_MEAN, 'std': IMAGENET_DEFAULT_STD,
|
|
'first_conv': 'conv1', 'classifier': 'fc',
|
|
**kwargs
|
|
}
|
|
|
|
|
|
default_cfgs = {
|
|
# ResNet and Wide ResNet
|
|
'resnet18': _cfg(url='https://download.pytorch.org/models/resnet18-5c106cde.pth'),
|
|
'resnet34': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet34-43635321.pth'),
|
|
'resnet26': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet26-9aa10e23.pth',
|
|
interpolation='bicubic'),
|
|
'resnet26d': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet26d-69e92c46.pth',
|
|
interpolation='bicubic'),
|
|
'resnet50': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnet50_ram-a26f946b.pth',
|
|
interpolation='bicubic'),
|
|
'resnet50d': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'resnet101': _cfg(url='https://download.pytorch.org/models/resnet101-5d3b4d8f.pth'),
|
|
'resnet152': _cfg(url='https://download.pytorch.org/models/resnet152-b121ed2d.pth'),
|
|
'tv_resnet34': _cfg(url='https://download.pytorch.org/models/resnet34-333f7ec4.pth'),
|
|
'tv_resnet50': _cfg(url='https://download.pytorch.org/models/resnet50-19c8e357.pth'),
|
|
'wide_resnet50_2': _cfg(url='https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth'),
|
|
'wide_resnet101_2': _cfg(url='https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth'),
|
|
|
|
# ResNeXt
|
|
'resnext50_32x4d': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnext50_32x4d_ra-d733960d.pth',
|
|
interpolation='bicubic'),
|
|
'resnext50d_32x4d': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnext50d_32x4d-103e99f8.pth',
|
|
interpolation='bicubic'),
|
|
'resnext101_32x4d': _cfg(url=''),
|
|
'resnext101_32x8d': _cfg(url='https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth'),
|
|
'resnext101_64x4d': _cfg(url=''),
|
|
'tv_resnext50_32x4d': _cfg(url='https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth'),
|
|
|
|
# ResNeXt models - Weakly Supervised Pretraining on Instagram Hashtags
|
|
# from https://github.com/facebookresearch/WSL-Images
|
|
# Please note the CC-BY-NC 4.0 license on theses weights, non-commercial use only.
|
|
'ig_resnext101_32x8d': _cfg(url='https://download.pytorch.org/models/ig_resnext101_32x8-c38310e5.pth'),
|
|
'ig_resnext101_32x16d': _cfg(url='https://download.pytorch.org/models/ig_resnext101_32x16-c6f796b0.pth'),
|
|
'ig_resnext101_32x32d': _cfg(url='https://download.pytorch.org/models/ig_resnext101_32x32-e4b90b00.pth'),
|
|
'ig_resnext101_32x48d': _cfg(url='https://download.pytorch.org/models/ig_resnext101_32x48-3e41cc8a.pth'),
|
|
|
|
# Semi-Supervised ResNe*t models from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models
|
|
# Please note the CC-BY-NC 4.0 license on theses weights, non-commercial use only.
|
|
'ssl_resnet18': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnet18-d92f0530.pth'),
|
|
'ssl_resnet50': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnet50-08389792.pth'),
|
|
'ssl_resnext50_32x4d': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnext50_32x4-ddb3e555.pth'),
|
|
'ssl_resnext101_32x4d': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnext101_32x4-dc43570a.pth'),
|
|
'ssl_resnext101_32x8d': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnext101_32x8-2cfe2f8b.pth'),
|
|
'ssl_resnext101_32x16d': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_supervised_resnext101_32x16-15fffa57.pth'),
|
|
|
|
# Semi-Weakly Supervised ResNe*t models from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models
|
|
# Please note the CC-BY-NC 4.0 license on theses weights, non-commercial use only.
|
|
'swsl_resnet18': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnet18-118f1556.pth'),
|
|
'swsl_resnet50': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnet50-16a12f1b.pth'),
|
|
'swsl_resnext50_32x4d': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnext50_32x4-72679e44.pth'),
|
|
'swsl_resnext101_32x4d': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnext101_32x4-3f87e46b.pth'),
|
|
'swsl_resnext101_32x8d': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnext101_32x8-b4712904.pth'),
|
|
'swsl_resnext101_32x16d': _cfg(
|
|
url='https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnext101_32x16-f3559a9c.pth'),
|
|
|
|
# Squeeze-Excitation ResNets, to eventually replace the models in senet.py
|
|
'seresnet18': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'seresnet34': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'seresnet50': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'seresnet50tn': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'seresnet101': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'seresnet152': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
|
|
# Squeeze-Excitation ResNeXts, to eventually replace the models in senet.py
|
|
'seresnext26_32x4d': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'seresnext26d_32x4d': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/seresnext26d_32x4d-80fa48a3.pth',
|
|
interpolation='bicubic'),
|
|
'seresnext26t_32x4d': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/seresnext26t_32x4d-361bc1c4.pth',
|
|
interpolation='bicubic'),
|
|
'seresnext26tn_32x4d': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/seresnext26tn_32x4d-569cb627.pth',
|
|
interpolation='bicubic'),
|
|
'seresnext50_32x4d': _cfg(
|
|
interpolation='bicubic'),
|
|
'seresnext101_32x4d': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'seresnext101_32x8d': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'senet154': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
|
|
# Efficient Channel Attention ResNets
|
|
'ecaresnet18': _cfg(),
|
|
'ecaresnet50': _cfg(),
|
|
'ecaresnetlight': _cfg(
|
|
url='https://imvl-automl-sh.oss-cn-shanghai.aliyuncs.com/darts/hyperml/hyperml/job_45402/outputs/ECAResNetLight_4f34b35b.pth',
|
|
interpolation='bicubic'),
|
|
'ecaresnet50d': _cfg(
|
|
url='https://imvl-automl-sh.oss-cn-shanghai.aliyuncs.com/darts/hyperml/hyperml/job_45402/outputs/ECAResNet50D_833caf58.pth',
|
|
interpolation='bicubic'),
|
|
'ecaresnet50d_pruned': _cfg(
|
|
url='https://imvl-automl-sh.oss-cn-shanghai.aliyuncs.com/darts/hyperml/hyperml/job_45899/outputs/ECAResNet50D_P_9c67f710.pth',
|
|
interpolation='bicubic'),
|
|
'ecaresnet101d': _cfg(
|
|
url='https://imvl-automl-sh.oss-cn-shanghai.aliyuncs.com/darts/hyperml/hyperml/job_45402/outputs/ECAResNet101D_281c5844.pth',
|
|
interpolation='bicubic'),
|
|
'ecaresnet101d_pruned': _cfg(
|
|
url='https://imvl-automl-sh.oss-cn-shanghai.aliyuncs.com/darts/hyperml/hyperml/job_45610/outputs/ECAResNet101D_P_75a3370e.pth',
|
|
interpolation='bicubic'),
|
|
|
|
# Efficient Channel Attention ResNeXts
|
|
'ecaresnext26tn_32x4d': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
'ecaresnext50_32x4d': _cfg(
|
|
url='',
|
|
interpolation='bicubic'),
|
|
|
|
# ResNets with anti-aliasing blur pool
|
|
'resnetblur18': _cfg(
|
|
interpolation='bicubic'),
|
|
'resnetblur50': _cfg(
|
|
url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnetblur50-84f4748f.pth',
|
|
interpolation='bicubic')
|
|
}
|
|
|
|
|
|
def get_padding(kernel_size, stride, dilation=1):
|
|
padding = ((stride - 1) + dilation * (kernel_size - 1)) // 2
|
|
return padding
|
|
|
|
|
|
class BasicBlock(nn.Module):
|
|
expansion = 1
|
|
|
|
def __init__(self, inplanes, planes, stride=1, downsample=None, cardinality=1, base_width=64,
|
|
reduce_first=1, dilation=1, first_dilation=None, act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d,
|
|
attn_layer=None, aa_layer=None, drop_block=None, drop_path=None):
|
|
super(BasicBlock, self).__init__()
|
|
|
|
assert cardinality == 1, 'BasicBlock only supports cardinality of 1'
|
|
assert base_width == 64, 'BasicBlock does not support changing base width'
|
|
first_planes = planes // reduce_first
|
|
outplanes = planes * self.expansion
|
|
first_dilation = first_dilation or dilation
|
|
use_aa = aa_layer is not None and (stride == 2 or first_dilation != dilation)
|
|
|
|
self.conv1 = nn.Conv2d(
|
|
inplanes, first_planes, kernel_size=3, stride=1 if use_aa else stride, padding=first_dilation,
|
|
dilation=first_dilation, bias=False)
|
|
self.bn1 = norm_layer(first_planes)
|
|
self.act1 = act_layer(inplace=True)
|
|
self.aa = aa_layer(channels=first_planes, stride=stride) if use_aa else None
|
|
|
|
self.conv2 = nn.Conv2d(
|
|
first_planes, outplanes, kernel_size=3, padding=dilation, dilation=dilation, bias=False)
|
|
self.bn2 = norm_layer(outplanes)
|
|
|
|
self.se = create_attn(attn_layer, outplanes)
|
|
|
|
self.act2 = act_layer(inplace=True)
|
|
self.downsample = downsample
|
|
self.stride = stride
|
|
self.dilation = dilation
|
|
self.drop_block = drop_block
|
|
self.drop_path = drop_path
|
|
|
|
def zero_init_last_bn(self):
|
|
nn.init.zeros_(self.bn2.weight)
|
|
|
|
def forward(self, x):
|
|
residual = x
|
|
|
|
x = self.conv1(x)
|
|
x = self.bn1(x)
|
|
if self.drop_block is not None:
|
|
x = self.drop_block(x)
|
|
x = self.act1(x)
|
|
if self.aa is not None:
|
|
x = self.aa(x)
|
|
|
|
x = self.conv2(x)
|
|
x = self.bn2(x)
|
|
if self.drop_block is not None:
|
|
x = self.drop_block(x)
|
|
|
|
if self.se is not None:
|
|
x = self.se(x)
|
|
|
|
if self.drop_path is not None:
|
|
x = self.drop_path(x)
|
|
|
|
if self.downsample is not None:
|
|
residual = self.downsample(residual)
|
|
x += residual
|
|
x = self.act2(x)
|
|
|
|
return x
|
|
|
|
|
|
class Bottleneck(nn.Module):
|
|
expansion = 4
|
|
|
|
def __init__(self, inplanes, planes, stride=1, downsample=None, cardinality=1, base_width=64,
|
|
reduce_first=1, dilation=1, first_dilation=None, act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d,
|
|
attn_layer=None, aa_layer=None, drop_block=None, drop_path=None):
|
|
super(Bottleneck, self).__init__()
|
|
|
|
width = int(math.floor(planes * (base_width / 64)) * cardinality)
|
|
first_planes = width // reduce_first
|
|
outplanes = planes * self.expansion
|
|
first_dilation = first_dilation or dilation
|
|
use_aa = aa_layer is not None and (stride == 2 or first_dilation != dilation)
|
|
|
|
self.conv1 = nn.Conv2d(inplanes, first_planes, kernel_size=1, bias=False)
|
|
self.bn1 = norm_layer(first_planes)
|
|
self.act1 = act_layer(inplace=True)
|
|
|
|
self.conv2 = nn.Conv2d(
|
|
first_planes, width, kernel_size=3, stride=1 if use_aa else stride,
|
|
padding=first_dilation, dilation=first_dilation, groups=cardinality, bias=False)
|
|
self.bn2 = norm_layer(width)
|
|
self.act2 = act_layer(inplace=True)
|
|
self.aa = aa_layer(channels=width, stride=stride) if use_aa else None
|
|
|
|
self.conv3 = nn.Conv2d(width, outplanes, kernel_size=1, bias=False)
|
|
self.bn3 = norm_layer(outplanes)
|
|
|
|
self.se = create_attn(attn_layer, outplanes)
|
|
|
|
self.act3 = act_layer(inplace=True)
|
|
self.downsample = downsample
|
|
self.stride = stride
|
|
self.dilation = dilation
|
|
self.drop_block = drop_block
|
|
self.drop_path = drop_path
|
|
|
|
def zero_init_last_bn(self):
|
|
nn.init.zeros_(self.bn3.weight)
|
|
|
|
def forward(self, x):
|
|
residual = x
|
|
|
|
x = self.conv1(x)
|
|
x = self.bn1(x)
|
|
if self.drop_block is not None:
|
|
x = self.drop_block(x)
|
|
x = self.act1(x)
|
|
|
|
x = self.conv2(x)
|
|
x = self.bn2(x)
|
|
if self.drop_block is not None:
|
|
x = self.drop_block(x)
|
|
x = self.act2(x)
|
|
if self.aa is not None:
|
|
x = self.aa(x)
|
|
|
|
x = self.conv3(x)
|
|
x = self.bn3(x)
|
|
if self.drop_block is not None:
|
|
x = self.drop_block(x)
|
|
|
|
if self.se is not None:
|
|
x = self.se(x)
|
|
|
|
if self.drop_path is not None:
|
|
x = self.drop_path(x)
|
|
|
|
if self.downsample is not None:
|
|
residual = self.downsample(residual)
|
|
x += residual
|
|
x = self.act3(x)
|
|
|
|
return x
|
|
|
|
|
|
def downsample_conv(
|
|
in_channels, out_channels, kernel_size, stride=1, dilation=1, first_dilation=None, norm_layer=None):
|
|
norm_layer = norm_layer or nn.BatchNorm2d
|
|
kernel_size = 1 if stride == 1 and dilation == 1 else kernel_size
|
|
first_dilation = (first_dilation or dilation) if kernel_size > 1 else 1
|
|
p = get_padding(kernel_size, stride, first_dilation)
|
|
|
|
return nn.Sequential(*[
|
|
nn.Conv2d(
|
|
in_channels, out_channels, kernel_size, stride=stride, padding=p, dilation=first_dilation, bias=False),
|
|
norm_layer(out_channels)
|
|
])
|
|
|
|
|
|
def downsample_avg(
|
|
in_channels, out_channels, kernel_size, stride=1, dilation=1, first_dilation=None, norm_layer=None):
|
|
norm_layer = norm_layer or nn.BatchNorm2d
|
|
avg_stride = stride if dilation == 1 else 1
|
|
if stride == 1 and dilation == 1:
|
|
pool = nn.Identity()
|
|
else:
|
|
avg_pool_fn = AvgPool2dSame if avg_stride == 1 and dilation > 1 else nn.AvgPool2d
|
|
pool = avg_pool_fn(2, avg_stride, ceil_mode=True, count_include_pad=False)
|
|
|
|
return nn.Sequential(*[
|
|
pool,
|
|
nn.Conv2d(in_channels, out_channels, 1, stride=1, padding=0, bias=False),
|
|
norm_layer(out_channels)
|
|
])
|
|
|
|
|
|
def drop_blocks(drop_block_rate=0.):
|
|
return [
|
|
None, None,
|
|
DropBlock2d(drop_block_rate, 5, 0.25) if drop_block_rate else None,
|
|
DropBlock2d(drop_block_rate, 3, 1.00) if drop_block_rate else None]
|
|
|
|
|
|
def make_blocks(
|
|
block_fn, channels, block_repeats, inplanes, reduce_first=1, output_stride=32,
|
|
down_kernel_size=1, avg_down=False, drop_block_rate=0., drop_path_rate=0., **kwargs):
|
|
stages = []
|
|
feature_info = []
|
|
net_num_blocks = sum(block_repeats)
|
|
net_block_idx = 0
|
|
net_stride = 4
|
|
dilation = prev_dilation = 1
|
|
for stage_idx, (planes, num_blocks, db) in enumerate(zip(channels, block_repeats, drop_blocks(drop_block_rate))):
|
|
stage_name = f'layer{stage_idx + 1}' # never liked this name, but weight compat requires it
|
|
stride = 1 if stage_idx == 0 else 2
|
|
if net_stride >= output_stride:
|
|
dilation *= stride
|
|
stride = 1
|
|
else:
|
|
net_stride *= stride
|
|
|
|
downsample = None
|
|
if stride != 1 or inplanes != planes * block_fn.expansion:
|
|
down_kwargs = dict(
|
|
in_channels=inplanes, out_channels=planes * block_fn.expansion, kernel_size=down_kernel_size,
|
|
stride=stride, dilation=dilation, first_dilation=prev_dilation, norm_layer=kwargs.get('norm_layer'))
|
|
downsample = downsample_avg(**down_kwargs) if avg_down else downsample_conv(**down_kwargs)
|
|
|
|
block_kwargs = dict(reduce_first=reduce_first, dilation=dilation, drop_block=db, **kwargs)
|
|
blocks = []
|
|
for block_idx in range(num_blocks):
|
|
downsample = downsample if block_idx == 0 else None
|
|
stride = stride if block_idx == 0 else 1
|
|
block_dpr = drop_path_rate * net_block_idx / (net_num_blocks - 1) # stochastic depth linear decay rule
|
|
blocks.append(block_fn(
|
|
inplanes, planes, stride, downsample, first_dilation=prev_dilation,
|
|
drop_path=DropPath(block_dpr) if block_dpr > 0. else None, **block_kwargs))
|
|
prev_dilation = dilation
|
|
inplanes = planes * block_fn.expansion
|
|
net_block_idx += 1
|
|
|
|
stages.append((stage_name, nn.Sequential(*blocks)))
|
|
feature_info.append(dict(num_chs=inplanes, reduction=net_stride, module=stage_name))
|
|
|
|
return stages, feature_info
|
|
|
|
|
|
class ResNet(nn.Module):
|
|
"""ResNet / ResNeXt / SE-ResNeXt / SE-Net
|
|
|
|
This class implements all variants of ResNet, ResNeXt, SE-ResNeXt, and SENet that
|
|
* have > 1 stride in the 3x3 conv layer of bottleneck
|
|
* have conv-bn-act ordering
|
|
|
|
This ResNet impl supports a number of stem and downsample options based on the v1c, v1d, v1e, and v1s
|
|
variants included in the MXNet Gluon ResNetV1b model. The C and D variants are also discussed in the
|
|
'Bag of Tricks' paper: https://arxiv.org/pdf/1812.01187. The B variant is equivalent to torchvision default.
|
|
|
|
ResNet variants (the same modifications can be used in SE/ResNeXt models as well):
|
|
* normal, b - 7x7 stem, stem_width = 64, same as torchvision ResNet, NVIDIA ResNet 'v1.5', Gluon v1b
|
|
* c - 3 layer deep 3x3 stem, stem_width = 32 (32, 32, 64)
|
|
* d - 3 layer deep 3x3 stem, stem_width = 32 (32, 32, 64), average pool in downsample
|
|
* e - 3 layer deep 3x3 stem, stem_width = 64 (64, 64, 128), average pool in downsample
|
|
* s - 3 layer deep 3x3 stem, stem_width = 64 (64, 64, 128)
|
|
* t - 3 layer deep 3x3 stem, stem width = 32 (24, 48, 64), average pool in downsample
|
|
* tn - 3 layer deep 3x3 stem, stem width = 32 (24, 32, 64), average pool in downsample
|
|
|
|
ResNeXt
|
|
* normal - 7x7 stem, stem_width = 64, standard cardinality and base widths
|
|
* same c,d, e, s variants as ResNet can be enabled
|
|
|
|
SE-ResNeXt
|
|
* normal - 7x7 stem, stem_width = 64
|
|
* same c, d, e, s variants as ResNet can be enabled
|
|
|
|
SENet-154 - 3 layer deep 3x3 stem (same as v1c-v1s), stem_width = 64, cardinality=64,
|
|
reduction by 2 on width of first bottleneck convolution, 3x3 downsample convs after first block
|
|
|
|
Parameters
|
|
----------
|
|
block : Block
|
|
Class for the residual block. Options are BasicBlockGl, BottleneckGl.
|
|
layers : list of int
|
|
Numbers of layers in each block
|
|
num_classes : int, default 1000
|
|
Number of classification classes.
|
|
in_chans : int, default 3
|
|
Number of input (color) channels.
|
|
cardinality : int, default 1
|
|
Number of convolution groups for 3x3 conv in Bottleneck.
|
|
base_width : int, default 64
|
|
Factor determining bottleneck channels. `planes * base_width / 64 * cardinality`
|
|
stem_width : int, default 64
|
|
Number of channels in stem convolutions
|
|
stem_type : str, default ''
|
|
The type of stem:
|
|
* '', default - a single 7x7 conv with a width of stem_width
|
|
* 'deep' - three 3x3 convolution layers of widths stem_width, stem_width, stem_width * 2
|
|
* 'deep_tiered' - three 3x3 conv layers of widths stem_width//4 * 3, stem_width//4 * 6, stem_width * 2
|
|
* 'deep_tiered_narrow' - three 3x3 conv layers of widths stem_width//4 * 3, stem_width, stem_width * 2
|
|
block_reduce_first: int, default 1
|
|
Reduction factor for first convolution output width of residual blocks,
|
|
1 for all archs except senets, where 2
|
|
down_kernel_size: int, default 1
|
|
Kernel size of residual block downsampling path, 1x1 for most archs, 3x3 for senets
|
|
avg_down : bool, default False
|
|
Whether to use average pooling for projection skip connection between stages/downsample.
|
|
output_stride : int, default 32
|
|
Set the output stride of the network, 32, 16, or 8. Typically used in segmentation.
|
|
act_layer : nn.Module, activation layer
|
|
norm_layer : nn.Module, normalization layer
|
|
aa_layer : nn.Module, anti-aliasing layer
|
|
drop_rate : float, default 0.
|
|
Dropout probability before classifier, for training
|
|
global_pool : str, default 'avg'
|
|
Global pooling type. One of 'avg', 'max', 'avgmax', 'catavgmax'
|
|
"""
|
|
|
|
def __init__(self, block, layers, num_classes=1000, in_chans=3,
|
|
cardinality=1, base_width=64, stem_width=64, stem_type='',
|
|
output_stride=32, block_reduce_first=1, down_kernel_size=1, avg_down=False,
|
|
act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d, aa_layer=None, drop_rate=0.0, drop_path_rate=0.,
|
|
drop_block_rate=0., global_pool='avg', zero_init_last_bn=True, block_args=None):
|
|
block_args = block_args or dict()
|
|
assert output_stride in (8, 16, 32)
|
|
self.num_classes = num_classes
|
|
self.drop_rate = drop_rate
|
|
super(ResNet, self).__init__()
|
|
|
|
# Stem
|
|
deep_stem = 'deep' in stem_type
|
|
inplanes = stem_width * 2 if deep_stem else 64
|
|
if deep_stem:
|
|
stem_chs_1 = stem_chs_2 = stem_width
|
|
if 'tiered' in stem_type:
|
|
stem_chs_1 = 3 * (stem_width // 4)
|
|
stem_chs_2 = stem_width if 'narrow' in stem_type else 6 * (stem_width // 4)
|
|
self.conv1 = nn.Sequential(*[
|
|
nn.Conv2d(in_chans, stem_chs_1, 3, stride=2, padding=1, bias=False),
|
|
norm_layer(stem_chs_1),
|
|
act_layer(inplace=True),
|
|
nn.Conv2d(stem_chs_1, stem_chs_2, 3, stride=1, padding=1, bias=False),
|
|
norm_layer(stem_chs_2),
|
|
act_layer(inplace=True),
|
|
nn.Conv2d(stem_chs_2, inplanes, 3, stride=1, padding=1, bias=False)])
|
|
else:
|
|
self.conv1 = nn.Conv2d(in_chans, inplanes, kernel_size=7, stride=2, padding=3, bias=False)
|
|
self.bn1 = norm_layer(inplanes)
|
|
self.act1 = act_layer(inplace=True)
|
|
self.feature_info = [dict(num_chs=inplanes, reduction=2, module='act1')]
|
|
|
|
# Stem Pooling
|
|
if aa_layer is not None:
|
|
self.maxpool = nn.Sequential(*[
|
|
nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
|
|
aa_layer(channels=inplanes, stride=2)])
|
|
else:
|
|
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
|
|
|
|
# Feature Blocks
|
|
channels = [64, 128, 256, 512]
|
|
stage_modules, stage_feature_info = make_blocks(
|
|
block, channels, layers, inplanes, cardinality=cardinality, base_width=base_width,
|
|
output_stride=output_stride, reduce_first=block_reduce_first, avg_down=avg_down,
|
|
down_kernel_size=down_kernel_size, act_layer=act_layer, norm_layer=norm_layer, aa_layer=aa_layer,
|
|
drop_block_rate=drop_block_rate, drop_path_rate=drop_path_rate, **block_args)
|
|
for stage in stage_modules:
|
|
self.add_module(*stage) # layer1, layer2, etc
|
|
self.feature_info.extend(stage_feature_info)
|
|
|
|
# Head (Pooling and Classifier)
|
|
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 n, m in self.named_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.)
|
|
if zero_init_last_bn:
|
|
for m in self.modules():
|
|
if hasattr(m, 'zero_init_last_bn'):
|
|
m.zero_init_last_bn()
|
|
|
|
def get_classifier(self):
|
|
return self.fc
|
|
|
|
def reset_classifier(self, num_classes, global_pool='avg'):
|
|
self.global_pool = SelectAdaptivePool2d(pool_type=global_pool)
|
|
self.num_classes = num_classes
|
|
if num_classes:
|
|
num_features = self.num_features * self.global_pool.feat_mult()
|
|
self.fc = nn.Linear(num_features, num_classes)
|
|
else:
|
|
self.fc = nn.Identity()
|
|
|
|
def forward_features(self, x):
|
|
x = self.conv1(x)
|
|
x = self.bn1(x)
|
|
x = self.act1(x)
|
|
x = self.maxpool(x)
|
|
|
|
x = self.layer1(x)
|
|
x = self.layer2(x)
|
|
x = self.layer3(x)
|
|
x = self.layer4(x)
|
|
return x
|
|
|
|
def forward(self, x):
|
|
x = self.forward_features(x)
|
|
x = self.global_pool(x).flatten(1)
|
|
if self.drop_rate:
|
|
x = F.dropout(x, p=float(self.drop_rate), training=self.training)
|
|
x = self.fc(x)
|
|
return x
|
|
|
|
|
|
def _create_resnet(variant, pretrained=False, **kwargs):
|
|
return build_model_with_cfg(
|
|
ResNet, variant, default_cfg=default_cfgs[variant], pretrained=pretrained, **kwargs)
|
|
|
|
|
|
@register_model
|
|
def resnet18(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-18 model.
|
|
"""
|
|
model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], **kwargs)
|
|
return _create_resnet('resnet18', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnet34(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-34 model.
|
|
"""
|
|
model_args = dict(block=BasicBlock, layers=[3, 4, 6, 3], **kwargs)
|
|
return _create_resnet('resnet34', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnet26(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-26 model.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[2, 2, 2, 2], **kwargs)
|
|
return _create_resnet('resnet26', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnet26d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-26 v1d model.
|
|
This is technically a 28 layer ResNet, sticking with 'd' modifier from Gluon for now.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[2, 2, 2, 2], stem_type='deep', avg_down=True, **kwargs)
|
|
return _create_resnet('resnet26d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnet50(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-50 model.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs)
|
|
return _create_resnet('resnet50', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnet50d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-50-D model.
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep', avg_down=True, **kwargs)
|
|
return _create_resnet('resnet50d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnet101(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-101 model.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], **kwargs)
|
|
return _create_resnet('resnet101', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnet152(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-152 model.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 8, 36, 3], **kwargs)
|
|
return _create_resnet('resnet152', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def tv_resnet34(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-34 model with original Torchvision weights.
|
|
"""
|
|
model_args = dict(block=BasicBlock, layers=[3, 4, 6, 3], **kwargs)
|
|
return _create_resnet('tv_resnet34', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def tv_resnet50(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-50 model with original Torchvision weights.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs)
|
|
return _create_resnet('tv_resnet50', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def wide_resnet50_2(pretrained=False, **kwargs):
|
|
"""Constructs a Wide ResNet-50-2 model.
|
|
The model is the same as ResNet except for the bottleneck number of channels
|
|
which is twice larger in every block. The number of channels in outer 1x1
|
|
convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
|
|
channels, and in Wide ResNet-50-2 has 2048-1024-2048.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], base_width=128, **kwargs)
|
|
return _create_resnet('wide_resnet50_2', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def wide_resnet101_2(pretrained=False, **kwargs):
|
|
"""Constructs a Wide ResNet-101-2 model.
|
|
The model is the same as ResNet except for the bottleneck number of channels
|
|
which is twice larger in every block. The number of channels in outer 1x1
|
|
convolutions is the same.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], base_width=128, **kwargs)
|
|
return _create_resnet('wide_resnet101_2', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnext50_32x4d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNeXt50-32x4d model.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4, **kwargs)
|
|
return _create_resnet('resnext50_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnext50d_32x4d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNeXt50d-32x4d model. ResNext50 w/ deep stem & avg pool downsample
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4,
|
|
stem_width=32, stem_type='deep', avg_down=True, **kwargs)
|
|
return _create_resnet('resnext50d_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnext101_32x4d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNeXt-101 32x4d model.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=4, **kwargs)
|
|
return _create_resnet('resnext101_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnext101_32x8d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNeXt-101 32x8d model.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8, **kwargs)
|
|
return _create_resnet('resnext101_32x8d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnext101_64x4d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNeXt101-64x4d model.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=64, base_width=4, **kwargs)
|
|
return _create_resnet('resnext101_64x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def tv_resnext50_32x4d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNeXt50-32x4d model with original Torchvision weights.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4, **kwargs)
|
|
return _create_resnet('tv_resnext50_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ig_resnext101_32x8d(pretrained=True, **kwargs):
|
|
"""Constructs a ResNeXt-101 32x8 model pre-trained on weakly-supervised data
|
|
and finetuned on ImageNet from Figure 5 in
|
|
`"Exploring the Limits of Weakly Supervised Pretraining" <https://arxiv.org/abs/1805.00932>`_
|
|
Weights from https://pytorch.org/hub/facebookresearch_WSL-Images_resnext/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8, **kwargs)
|
|
return _create_resnet('ig_resnext101_32x8d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ig_resnext101_32x16d(pretrained=True, **kwargs):
|
|
"""Constructs a ResNeXt-101 32x16 model pre-trained on weakly-supervised data
|
|
and finetuned on ImageNet from Figure 5 in
|
|
`"Exploring the Limits of Weakly Supervised Pretraining" <https://arxiv.org/abs/1805.00932>`_
|
|
Weights from https://pytorch.org/hub/facebookresearch_WSL-Images_resnext/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=16, **kwargs)
|
|
return _create_resnet('ig_resnext101_32x16d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ig_resnext101_32x32d(pretrained=True, **kwargs):
|
|
"""Constructs a ResNeXt-101 32x32 model pre-trained on weakly-supervised data
|
|
and finetuned on ImageNet from Figure 5 in
|
|
`"Exploring the Limits of Weakly Supervised Pretraining" <https://arxiv.org/abs/1805.00932>`_
|
|
Weights from https://pytorch.org/hub/facebookresearch_WSL-Images_resnext/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=32, **kwargs)
|
|
return _create_resnet('ig_resnext101_32x32d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ig_resnext101_32x48d(pretrained=True, **kwargs):
|
|
"""Constructs a ResNeXt-101 32x48 model pre-trained on weakly-supervised data
|
|
and finetuned on ImageNet from Figure 5 in
|
|
`"Exploring the Limits of Weakly Supervised Pretraining" <https://arxiv.org/abs/1805.00932>`_
|
|
Weights from https://pytorch.org/hub/facebookresearch_WSL-Images_resnext/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=48, **kwargs)
|
|
return _create_resnet('ig_resnext101_32x48d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ssl_resnet18(pretrained=True, **kwargs):
|
|
"""Constructs a semi-supervised ResNet-18 model pre-trained on YFCC100M dataset and finetuned on ImageNet
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], **kwargs)
|
|
return _create_resnet('ssl_resnet18', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ssl_resnet50(pretrained=True, **kwargs):
|
|
"""Constructs a semi-supervised ResNet-50 model pre-trained on YFCC100M dataset and finetuned on ImageNet
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs)
|
|
return _create_resnet('ssl_resnet50', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ssl_resnext50_32x4d(pretrained=True, **kwargs):
|
|
"""Constructs a semi-supervised ResNeXt-50 32x4 model pre-trained on YFCC100M dataset and finetuned on ImageNet
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4, **kwargs)
|
|
return _create_resnet('ssl_resnext50_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ssl_resnext101_32x4d(pretrained=True, **kwargs):
|
|
"""Constructs a semi-supervised ResNeXt-101 32x4 model pre-trained on YFCC100M dataset and finetuned on ImageNet
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=4, **kwargs)
|
|
return _create_resnet('ssl_resnext101_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ssl_resnext101_32x8d(pretrained=True, **kwargs):
|
|
"""Constructs a semi-supervised ResNeXt-101 32x8 model pre-trained on YFCC100M dataset and finetuned on ImageNet
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8, **kwargs)
|
|
return _create_resnet('ssl_resnext101_32x8d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ssl_resnext101_32x16d(pretrained=True, **kwargs):
|
|
"""Constructs a semi-supervised ResNeXt-101 32x16 model pre-trained on YFCC100M dataset and finetuned on ImageNet
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=16, **kwargs)
|
|
return _create_resnet('ssl_resnext101_32x16d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def swsl_resnet18(pretrained=True, **kwargs):
|
|
"""Constructs a semi-weakly supervised Resnet-18 model pre-trained on 1B weakly supervised
|
|
image dataset and finetuned on ImageNet.
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], **kwargs)
|
|
return _create_resnet('swsl_resnet18', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def swsl_resnet50(pretrained=True, **kwargs):
|
|
"""Constructs a semi-weakly supervised ResNet-50 model pre-trained on 1B weakly supervised
|
|
image dataset and finetuned on ImageNet.
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], **kwargs)
|
|
return _create_resnet('swsl_resnet50', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def swsl_resnext50_32x4d(pretrained=True, **kwargs):
|
|
"""Constructs a semi-weakly supervised ResNeXt-50 32x4 model pre-trained on 1B weakly supervised
|
|
image dataset and finetuned on ImageNet.
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4, **kwargs)
|
|
return _create_resnet('swsl_resnext50_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def swsl_resnext101_32x4d(pretrained=True, **kwargs):
|
|
"""Constructs a semi-weakly supervised ResNeXt-101 32x4 model pre-trained on 1B weakly supervised
|
|
image dataset and finetuned on ImageNet.
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=4, **kwargs)
|
|
return _create_resnet('swsl_resnext101_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def swsl_resnext101_32x8d(pretrained=True, **kwargs):
|
|
"""Constructs a semi-weakly supervised ResNeXt-101 32x8 model pre-trained on 1B weakly supervised
|
|
image dataset and finetuned on ImageNet.
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8, **kwargs)
|
|
return _create_resnet('swsl_resnext101_32x8d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def swsl_resnext101_32x16d(pretrained=True, **kwargs):
|
|
"""Constructs a semi-weakly supervised ResNeXt-101 32x16 model pre-trained on 1B weakly supervised
|
|
image dataset and finetuned on ImageNet.
|
|
`"Billion-scale Semi-Supervised Learning for Image Classification" <https://arxiv.org/abs/1905.00546>`_
|
|
Weights from https://github.com/facebookresearch/semi-supervised-ImageNet1K-models/
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=16, **kwargs)
|
|
return _create_resnet('swsl_resnext101_32x16d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ecaresnet18(pretrained=False, **kwargs):
|
|
""" Constructs an ECA-ResNet-18 model.
|
|
"""
|
|
model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], block_args=dict(attn_layer='eca'), **kwargs)
|
|
return _create_resnet('ecaresnet18', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ecaresnet50(pretrained=False, **kwargs):
|
|
"""Constructs an ECA-ResNet-50 model.
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], block_args=dict(attn_layer='eca'), **kwargs)
|
|
return _create_resnet('ecaresnet50', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ecaresnet50d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-50-D model with eca.
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep', avg_down=True,
|
|
block_args=dict(attn_layer='eca'), **kwargs)
|
|
return _create_resnet('ecaresnet50d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ecaresnet50d_pruned(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-50-D model pruned with eca.
|
|
The pruning has been obtained using https://arxiv.org/pdf/2002.08258.pdf
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep', avg_down=True,
|
|
block_args=dict(attn_layer='eca'), **kwargs)
|
|
return _create_resnet('ecaresnet50d_pruned', pretrained, pruned=True, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ecaresnetlight(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-50-D light model with eca.
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[1, 1, 11, 3], stem_width=32, avg_down=True,
|
|
block_args=dict(attn_layer='eca'), **kwargs)
|
|
return _create_resnet('ecaresnetlight', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ecaresnet101d(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-101-D model with eca.
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 23, 3], stem_width=32, stem_type='deep', avg_down=True,
|
|
block_args=dict(attn_layer='eca'), **kwargs)
|
|
return _create_resnet('ecaresnet101d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ecaresnet101d_pruned(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-101-D model pruned with eca.
|
|
The pruning has been obtained using https://arxiv.org/pdf/2002.08258.pdf
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 23, 3], stem_width=32, stem_type='deep', avg_down=True,
|
|
block_args=dict(attn_layer='eca'), **kwargs)
|
|
return _create_resnet('ecaresnet101d_pruned', pretrained, pruned=True, **model_args)
|
|
|
|
|
|
@register_model
|
|
def ecaresnext26tn_32x4d(pretrained=False, **kwargs):
|
|
"""Constructs an ECA-ResNeXt-26-TN model.
|
|
This is technically a 28 layer ResNet, like a 'D' bag-of-tricks model but with tiered 24, 32, 64 channels
|
|
in the deep stem. The channel number of the middle stem conv is narrower than the 'T' variant.
|
|
this model replaces SE module with the ECA module
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[2, 2, 2, 2], cardinality=32, base_width=4, stem_width=32,
|
|
stem_type='deep_tiered_narrow', avg_down=True, block_args=dict(attn_layer='eca'), **kwargs)
|
|
return _create_resnet('ecaresnext26tn_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnetblur18(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-18 model with blur anti-aliasing
|
|
"""
|
|
model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], aa_layer=BlurPool2d, **kwargs)
|
|
return _create_resnet('resnetblur18', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def resnetblur50(pretrained=False, **kwargs):
|
|
"""Constructs a ResNet-50 model with blur anti-aliasing
|
|
"""
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], aa_layer=BlurPool2d, **kwargs)
|
|
return _create_resnet('resnetblur50', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnet18(pretrained=False, **kwargs):
|
|
model_args = dict(block=BasicBlock, layers=[2, 2, 2, 2], block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnet18', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnet34(pretrained=False, **kwargs):
|
|
model_args = dict(block=BasicBlock, layers=[3, 4, 6, 3], block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnet34', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnet50(pretrained=False, **kwargs):
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnet50', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnet50tn(pretrained=False, **kwargs):
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep_tiered_narrow', avg_down=True,
|
|
block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnet50tn', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnet101(pretrained=False, **kwargs):
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 23, 3], block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnet101', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnet152(pretrained=False, **kwargs):
|
|
model_args = dict(block=Bottleneck, layers=[3, 8, 36, 3], block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnet152', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnext26_32x4d(pretrained=False, **kwargs):
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[2, 2, 2, 2], cardinality=32, base_width=4,
|
|
block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnext26_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnext26d_32x4d(pretrained=False, **kwargs):
|
|
"""Constructs a SE-ResNeXt-26-D model.`
|
|
This is technically a 28 layer ResNet, using the 'D' modifier from Gluon / bag-of-tricks for
|
|
combination of deep stem and avg_pool in downsample.
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[2, 2, 2, 2], cardinality=32, base_width=4, stem_width=32,
|
|
stem_type='deep', avg_down=True, block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnext26d_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnext26t_32x4d(pretrained=False, **kwargs):
|
|
"""Constructs a SE-ResNet-26-T model.
|
|
This is technically a 28 layer ResNet, like a 'D' bag-of-tricks model but with tiered 24, 48, 64 channels
|
|
in the deep stem.
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[2, 2, 2, 2], cardinality=32, base_width=4, stem_width=32,
|
|
stem_type='deep_tiered', avg_down=True, block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnext26t_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnext26tn_32x4d(pretrained=False, **kwargs):
|
|
"""Constructs a SE-ResNeXt-26-TN model.
|
|
This is technically a 28 layer ResNet, like a 'D' bag-of-tricks model but with tiered 24, 32, 64 channels
|
|
in the deep stem. The channel number of the middle stem conv is narrower than the 'T' variant.
|
|
"""
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[2, 2, 2, 2], cardinality=32, base_width=4, stem_width=32,
|
|
stem_type='deep_tiered_narrow', avg_down=True, block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnext26tn_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnext50_32x4d(pretrained=False, **kwargs):
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4,
|
|
block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnext50_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnext101_32x4d(pretrained=False, **kwargs):
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=4,
|
|
block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnext101_32x4d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def seresnext101_32x8d(pretrained=False, **kwargs):
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 4, 23, 3], cardinality=32, base_width=8,
|
|
block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('seresnext101_32x8d', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def senet154(pretrained=False, **kwargs):
|
|
model_args = dict(
|
|
block=Bottleneck, layers=[3, 8, 36, 3], cardinality=64, base_width=4, stem_type='deep',
|
|
down_kernel_size=3, block_reduce_first=2, block_args=dict(attn_layer='se'), **kwargs)
|
|
return _create_resnet('senet154', pretrained, **model_args)
|
|
|
|
|
|
@register_model
|
|
def eseresnet50(pretrained=False, **kwargs):
|
|
model_args = dict(block=Bottleneck, layers=[3, 4, 6, 3], block_args=dict(attn_layer='ese'), **kwargs)
|
|
return _create_resnet('seresnet50', pretrained, **model_args)
|