Skip to content

P
PaddleClas

PaddlePaddle / PaddleClas
10 个月 前同步成功

通知 115
Star 4999
Fork 1114
P
PaddleClas

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 20a08a41 编写于 作者: W wqz960
浏览文件
操作

add en docs and fix format

上级 16984f5f
隐藏空白更改
内联 并排
Showing with 557 addition and 351 deletion
configs/ResNeSt/ResNeSt50.yaml
浏览文件 @ 20a08a41
...@@ -45,6 +45,7 @@ TRAIN: ...@@ -45,6 +45,7 @@ TRAIN:
- RandFlipImage: - RandFlipImage:
flip_code: 1 flip_code: 1
- AutoAugment: - AutoAugment:
- RandomErasing:
- NormalizeImage: - NormalizeImage:
scale: 1./255. scale: 1./255.
mean: [0.485, 0.456, 0.406] mean: [0.485, 0.456, 0.406]
......
docs/en/models/ResNeSt_RegNet.md 0 → 100644
浏览文件 @ 20a08a41
## Overview
The ResNeSt series was proposed in 2020. The original resnet network structure has been improved by introducing K groups and adding an attention module similar to SEBlock in different groups, the accuracy is greater than that of the basic model ResNet, but the parameter amount and flops are almost the same as the basic ResNet.
## Accuracy, FLOPs and Parameters
| Models | Top1 | Top5 | Reference<br>top1 | Reference<br>top5 | FLOPS<br>(G) | Parameters<br>(M) |
|:--:|:--:|:--:|:--:|:--:|:--:|:--:|
| ResNeSt50 | 0.8102 | 0.9542| 0.8113 | -|5.39 | 27.5 |
\ No newline at end of file
ppcls/modeling/architectures/__init__.py
浏览文件 @ 20a08a41
...@@ -43,6 +43,7 @@ from .hrnet import HRNet_W18_C, HRNet_W30_C, HRNet_W32_C, HRNet_W40_C, HRNet_W44 ...@@ -43,6 +43,7 @@ from .hrnet import HRNet_W18_C, HRNet_W30_C, HRNet_W32_C, HRNet_W40_C, HRNet_W44
from .darts_gs import DARTS_GS_6M, DARTS_GS_4M from .darts_gs import DARTS_GS_6M, DARTS_GS_4M
from .resnet_acnet import ResNet18_ACNet, ResNet34_ACNet, ResNet50_ACNet, ResNet101_ACNet, ResNet152_ACNet from .resnet_acnet import ResNet18_ACNet, ResNet34_ACNet, ResNet50_ACNet, ResNet101_ACNet, ResNet152_ACNet
from .ghostnet import GhostNet_x0_5, GhostNet_x1_0, GhostNet_x1_3 from .ghostnet import GhostNet_x0_5, GhostNet_x1_0, GhostNet_x1_3
from .resnest import ResNeSt50, ResNeSt101, ResNeSt200, ResNeSt269, ResNeSt50_fast_1s1x64d, ResNeSt50_fast_2s1x64d, ResNeSt50_fast_4s1x64d, ResNeSt50_fast_1s2x40d, ResNeSt50_fast_2s2x40d, ResNeSt50_fast_2s2x40d, ResNeSt50_fast_4s2x40d, ResNeSt50_fast_1s4x24d
# distillation model # distillation model
from .distillation_models import ResNet50_vd_distill_MobileNetV3_large_x1_0, ResNeXt101_32x16d_wsl_distill_ResNet50_vd from .distillation_models import ResNet50_vd_distill_MobileNetV3_large_x1_0, ResNeXt101_32x16d_wsl_distill_ResNet50_vd
......
ppcls/modeling/architectures/resnest.py
浏览文件 @ 20a08a41
...@@ -7,447 +7,642 @@ from paddle.fluid.initializer import MSRA, ConstantInitializer ...@@ -7,447 +7,642 @@ from paddle.fluid.initializer import MSRA, ConstantInitializer
from paddle.fluid.param_attr import ParamAttr from paddle.fluid.param_attr import ParamAttr
from paddle.fluid.regularizer import L2DecayRegularizer from paddle.fluid.regularizer import L2DecayRegularizer
import math import math
from paddle.fluid.contrib.model_stat import summary
__all__ = ['ResNeSt50', 'ResNeSt101', 'ResNeSt200', 'ResNeSt269', __all__ = [
'ResNeSt50_fast_1s1x64d', 'ResNeSt50_fast_2s1x64d', 'ResNeSt50', 'ResNeSt101', 'ResNeSt200', 'ResNeSt269',
'ResNeSt50_fast_4s1x64d', 'ResNeSt50_fast_1s2x40d', 'ResNeSt50_fast_1s1x64d', 'ResNeSt50_fast_2s1x64d',
'ResNeSt50_fast_2s2x40d', 'ResNeSt50_fast_2s2x40d', 'ResNeSt50_fast_4s1x64d', 'ResNeSt50_fast_1s2x40d',
'ResNeSt50_fast_4s2x40d', 'ResNeSt50_fast_1s4x24d'] 'ResNeSt50_fast_2s2x40d', 'ResNeSt50_fast_2s2x40d',
'ResNeSt50_fast_4s2x40d', 'ResNeSt50_fast_1s4x24d'
]
class ResNeSt(): class ResNeSt():
def __init__(self, layers, radix=1, groups=1, bottleneck_width=64, dilated=False, def __init__(self,
dilation=1, deep_stem=False, stem_width=64, avg_down=False, layers,
rectify_avg=False, avd=False, avd_first=False, final_drop=0.0, radix=1,
last_gamma=False, bn_decay=0.0): groups=1,
bottleneck_width=64,
dilated=False,
dilation=1,
deep_stem=False,
stem_width=64,
avg_down=False,
rectify_avg=False,
avd=False,
avd_first=False,
final_drop=0.0,
last_gamma=False,
bn_decay=0.0):
self.cardinality = groups self.cardinality = groups
self.bottleneck_width = bottleneck_width self.bottleneck_width = bottleneck_width
# ResNet-D params # ResNet-D params
self.inplanes = stem_width*2 if deep_stem else 64 self.inplanes = stem_width * 2 if deep_stem else 64
self.avg_down = avg_down self.avg_down = avg_down
self.last_gamma = last_gamma self.last_gamma = last_gamma
# ResNeSt params # ResNeSt params
self.radix = radix self.radix = radix
self.avd = avd self.avd = avd
self.avd_first = avd_first self.avd_first = avd_first
self.deep_stem = deep_stem self.deep_stem = deep_stem
self.stem_width = stem_width self.stem_width = stem_width
self.layers = layers self.layers = layers
self.final_drop = final_drop self.final_drop = final_drop
self.dilated = dilated self.dilated = dilated
self.dilation = dilation self.dilation = dilation
self.bn_decay = 0.0 # bn_decay self.bn_decay = bn_decay
self.rectify_avg = rectify_avg self.rectify_avg = rectify_avg
def net(self, input, class_dim=1000): def net(self, input, class_dim=1000):
if self.deep_stem: if self.deep_stem:
x = self.conv_bn_layer(x=input, x = self.conv_bn_layer(
num_filters=self.stem_width, x=input,
filters_size=3, num_filters=self.stem_width,
stride=2, filters_size=3,
groups=1, stride=2,
act="relu", groups=1,
name="conv1") act="relu",
x = self.conv_bn_layer(x=x, name="conv1")
num_filters=self.stem_width, x = self.conv_bn_layer(
filters_size=3, x=x,
stride=1, num_filters=self.stem_width,
groups=1, filters_size=3,
act="relu", stride=1,
name="conv2") groups=1,
x = self.conv_bn_layer(x=x, act="relu",
num_filters=self.stem_width*2, name="conv2")
filters_size=3, x = self.conv_bn_layer(
stride=1, x=x,
groups=1, num_filters=self.stem_width * 2,
act="relu", filters_size=3,
name="conv3") stride=1,
groups=1,
act="relu",
name="conv3")
else: else:
x = self.conv_bn_layer(x=input, x = self.conv_bn_layer(
num_filters=64, x=input,
filters_size=7, num_filters=64,
stride=2, filters_size=7,
act="relu", stride=2,
name="conv1") act="relu",
name="conv1")
x = fluid.layers.pool2d(input=x,
pool_size=3, x = fluid.layers.pool2d(
pool_type="max", input=x,
pool_stride=2, pool_size=3,
pool_padding=1) pool_type="max",
pool_stride=2,
x = self.resnest_layer(x=x, pool_padding=1)
planes=64,
blocks=self.layers[0], x = self.resnest_layer(
is_first=False, x=x,
name="layer1") planes=64,
x = self.resnest_layer(x=x, blocks=self.layers[0],
planes=128, is_first=False,
blocks=self.layers[1], name="layer1")
stride=2, x = self.resnest_layer(
name="layer2") x=x,
if self.dilated or self.dilation==4: planes=128,
x = self.resnest_layer(x=x, blocks=self.layers[1],
planes=256, stride=2,
blocks=self.layers[2], name="layer2")
stride=1, if self.dilated or self.dilation == 4:
dilation=2, x = self.resnest_layer(
name="layer3") x=x,
x = self.resnest_layer(x=x, planes=256,
planes=512, blocks=self.layers[2],
blocks=self.layers[3], stride=1,
stride=1, dilation=2,
dilation=4, name="layer3")
name="layer4") x = self.resnest_layer(
elif self.dilation==2: x=x,
x = self.resnest_layer(x=x, planes=512,
planes=256, blocks=self.layers[3],
blocks=self.layers[2], stride=1,
stride=2, dilation=4,
dilation=1, name="layer4")
name="layer3") elif self.dilation == 2:
x = self.resnest_layer(x=x, x = self.resnest_layer(
planes=512, x=x,
blocks=self.layers[3], planes=256,
stride=1, blocks=self.layers[2],
dilation=2, stride=2,
name="layer4") dilation=1,
name="layer3")
x = self.resnest_layer(
x=x,
planes=512,
blocks=self.layers[3],
stride=1,
dilation=2,
name="layer4")
else: else:
x = self.resnest_layer(x=x, x = self.resnest_layer(
planes=256, x=x,
blocks=self.layers[2], planes=256,
stride=2, blocks=self.layers[2],
name="layer3") stride=2,
x = self.resnest_layer(x=x, name="layer3")
planes=512, x = self.resnest_layer(
blocks=self.layers[3], x=x,
stride=2, planes=512,
name="layer4") blocks=self.layers[3],
x = fluid.layers.pool2d(input=x, pool_type="avg", global_pooling=True, name="global_avg") stride=2,
x = fluid.layers.dropout(x=x, dropout_prob=self.final_drop, name="final_drop") name="layer4")
stdv=1.0/math.sqrt(x.shape[1]*1.0) x = fluid.layers.pool2d(
x = fluid.layers.fc(input=x, size=class_dim, input=x, pool_type="avg", global_pooling=True)
param_attr=fluid.param_attr.ParamAttr(name="fc_weights", x = fluid.layers.dropout(
initializer=fluid.initializer.Uniform(-stdv, stdv)), x=x, dropout_prob=self.final_drop)
bias_attr=ParamAttr(name="fc_offset")) stdv = 1.0 / math.sqrt(x.shape[1] * 1.0)
x = fluid.layers.fc(
input=x,
size=class_dim,
param_attr=ParamAttr(
name="fc_weights",
initializer=fluid.initializer.Uniform(-stdv, stdv)),
bias_attr=ParamAttr(name="fc_offset"))
return x return x
def conv_bn_layer(self, def conv_bn_layer(self,
x, x,
num_filters, num_filters,
filters_size, filters_size,
stride=1, stride=1,
groups=1, groups=1,
act=None, act=None,
name=None): name=None):
x = fluid.layers.conv2d(input=x, x = fluid.layers.conv2d(
num_filters=num_filters, input=x,
filter_size=filters_size, num_filters=num_filters,
stride=stride, filter_size=filters_size,
padding=(filters_size-1)//2, stride=stride,
groups=groups, padding=(filters_size - 1) // 2,
act=None, groups=groups,
param_attr=ParamAttr(initializer=MSRA(), name=name+"_weight"), act=None,
bias_attr=False) param_attr=ParamAttr(
x = fluid.layers.batch_norm(input=x, initializer=MSRA(), name=name + "_weight"),
act=act, bias_attr=False)
param_attr=ParamAttr(name=name+"_scale", x = fluid.layers.batch_norm(
regularizer=L2DecayRegularizer(regularization_coeff=self.bn_decay)), input=x,
bias_attr=ParamAttr(name=name+"_offset", act=act,
regularizer=L2DecayRegularizer(regularization_coeff=self.bn_decay)), param_attr=ParamAttr(
moving_mean_name=name+"_mean", name=name + "_scale",
moving_variance_name=name+"_variance") regularizer=L2DecayRegularizer(
regularization_coeff=self.bn_decay)),
bias_attr=ParamAttr(
name=name + "_offset",
regularizer=L2DecayRegularizer(
regularization_coeff=self.bn_decay)),
moving_mean_name=name + "_mean",
moving_variance_name=name + "_variance")
return x return x
def rsoftmax(self, x, radix, cardinality, name=None): def rsoftmax(self, x, radix, cardinality):
batch, r, h, w = x.shape batch, r, h, w = x.shape
if radix > 1: if radix > 1:
x = fluid.layers.reshape(x=x, x = fluid.layers.reshape(
shape=[0, cardinality, radix, int(r*h*w/cardinality/radix)]) x=x,
shape=[
0, cardinality, radix, int(r * h * w / cardinality / radix)
])
x = fluid.layers.transpose(x=x, perm=[0, 2, 1, 3]) x = fluid.layers.transpose(x=x, perm=[0, 2, 1, 3])
x = fluid.layers.softmax(input=x, axis=1) x = fluid.layers.softmax(input=x, axis=1)
x = fluid.layers.reshape(x=x, x = fluid.layers.reshape(x=x, shape=[0, r * h * w])
shape=[0, r*h*w])
else: else:
x = fluid.layers.sigmoid(x=x) x = fluid.layers.sigmoid(x=x)
return x return x
def splat_conv(self, x, in_channels, channels, kernel_size, stride=1, padding=0, def splat_conv(self,
dilation=1, groups=1, bias=True, radix=2, reduction_factor=4, x,
rectify_avg=False, name=None): in_channels,
x = self.conv_bn_layer(x=x, channels,
num_filters=channels*radix, kernel_size,
filters_size=kernel_size, stride=1,
stride=stride, padding=0,
groups=groups*radix, dilation=1,
act="relu", groups=1,
name=name+"_splat1") bias=True,
radix=2,
reduction_factor=4,
rectify_avg=False,
name=None):
x = self.conv_bn_layer(
x=x,
num_filters=channels * radix,
filters_size=kernel_size,
stride=stride,
groups=groups * radix,
act="relu",
name=name + "_splat1")
batch, rchannel = x.shape[:2] batch, rchannel = x.shape[:2]
if radix>1: if radix > 1:
splited = fluid.layers.split(input=x, num_or_sections=radix, dim=1) splited = fluid.layers.split(input=x, num_or_sections=radix, dim=1)
gap = fluid.layers.sum(x=splited) gap = fluid.layers.sum(x=splited)
else: else:
gap = x gap = x
gap = fluid.layers.pool2d(input=gap, pool_type="avg", global_pooling=True) gap = fluid.layers.pool2d(
inter_channels = int(max(in_channels*radix//reduction_factor, 32)) input=gap, pool_type="avg", global_pooling=True)
gap = self.conv_bn_layer(x=gap, inter_channels = int(max(in_channels * radix // reduction_factor, 32))
num_filters=inter_channels, gap = self.conv_bn_layer(
filters_size=1, x=gap,
groups=groups, num_filters=inter_channels,
act="relu", filters_size=1,
name=name+"_splat2") groups=groups,
act="relu",
atten = fluid.layers.conv2d(input=gap, name=name + "_splat2")
num_filters=channels*radix,
filter_size=1, atten = fluid.layers.conv2d(
stride=1, input=gap,
padding=0, num_filters=channels * radix,
groups=groups, filter_size=1,
act=None, stride=1,
param_attr=ParamAttr(name=name+"_splat_weights", initializer=MSRA()), padding=0,
bias_attr=False) groups=groups,
atten = self.rsoftmax(x=atten, act=None,
radix=radix, param_attr=ParamAttr(
cardinality=groups, name=name + "_splat_weights", initializer=MSRA()),
name=name+"_rsoftmax") bias_attr=False)
atten = self.rsoftmax(
x=atten, radix=radix, cardinality=groups)
atten = fluid.layers.reshape(x=atten, shape=[-1, atten.shape[1], 1, 1]) atten = fluid.layers.reshape(x=atten, shape=[-1, atten.shape[1], 1, 1])
if radix > 1: if radix > 1:
attens = fluid.layers.split(input=atten, num_or_sections=radix, dim=1) attens = fluid.layers.split(
out = fluid.layers.sum([fluid.layers.elementwise_mul(x=att, y=split) for (att, split) in zip(attens, splited)]) input=atten, num_or_sections=radix, dim=1)
out = fluid.layers.sum([
fluid.layers.elementwise_mul(
x=att, y=split) for (att, split) in zip(attens, splited)
])
else: else:
out = fluid.layers.elementwise_mul(atten, x) out = fluid.layers.elementwise_mul(atten, x)
return out return out
def bottleneck(self,
def bottleneck(self, x, inplanes, planes, stride=1, radix=1, cardinality=1, bottleneck_width=64, x,
avd=False, avd_first=False, dilation=1, is_first=False, rectify_avg=False, inplanes,
last_gamma=False, name=None): planes,
stride=1,
radix=1,
cardinality=1,
bottleneck_width=64,
avd=False,
avd_first=False,
dilation=1,
is_first=False,
rectify_avg=False,
last_gamma=False,
name=None):
short = x short = x
group_width = int(planes * (bottleneck_width/64.)) * cardinality group_width = int(planes * (bottleneck_width / 64.)) * cardinality
x = self.conv_bn_layer(x=x, x = self.conv_bn_layer(
num_filters=group_width, x=x,
filters_size=1, num_filters=group_width,
stride=1, filters_size=1,
groups=1, stride=1,
act="relu", groups=1,
name=name+"_conv1") act="relu",
if avd and avd_first and (stride>1 or is_first): name=name + "_conv1")
x = fluid.layers.pool2d(input=x, if avd and avd_first and (stride > 1 or is_first):
pool_size=3, x = fluid.layers.pool2d(
pool_type="avg", input=x,
pool_stride=stride, pool_size=3,
pool_padding=1) pool_type="avg",
pool_stride=stride,
pool_padding=1)
if radix >= 1: if radix >= 1:
x = self.splat_conv(x=x, x = self.splat_conv(
in_channels=group_width, x=x,
channels=group_width, in_channels=group_width,
kernel_size=3, channels=group_width,
stride=1, kernel_size=3,
padding=dilation, stride=1,
dilation=dilation, padding=dilation,
groups=cardinality, dilation=dilation,
bias=False, groups=cardinality,
radix=radix, bias=False,
rectify_avg=rectify_avg, radix=radix,
name=name+"_splatconv") rectify_avg=rectify_avg,
name=name + "_splatconv")
else: else:
x = self.conv_bn_layer(x=x, x = self.conv_bn_layer(
num_filters=group_width, x=x,
filters_size=3, num_filters=group_width,
stride=1, filters_size=3,
padding=dilation, stride=1,
dilation=dialtion, padding=dilation,
groups=cardinality, dilation=dialtion,
act="relu", groups=cardinality,
name=name+"_conv2") act="relu",
name=name + "_conv2")
if avd and avd_first==False and (stride>1 or is_first):
x = fluid.layers.pool2d(input=x, if avd and avd_first == False and (stride > 1 or is_first):
pool_size=3, x = fluid.layers.pool2d(
pool_type="avg", input=x,
pool_stride=stride, pool_size=3,
pool_padding=1) pool_type="avg",
x = self.conv_bn_layer(x=x, pool_stride=stride,
num_filters=planes*4, pool_padding=1)
filters_size=1, x = self.conv_bn_layer(
stride=1, x=x,
groups=1, num_filters=planes * 4,
act=None, filters_size=1,
name=name+"_conv3") stride=1,
groups=1,
if stride!=1 or self.inplanes != planes * 4: act=None,
name=name + "_conv3")
if stride != 1 or self.inplanes != planes * 4:
if self.avg_down: if self.avg_down:
if dilation==1: if dilation == 1:
short = fluid.layers.pool2d(input=short, short = fluid.layers.pool2d(
pool_size=stride, input=short,
pool_type="avg", pool_size=stride,
pool_stride=stride, pool_type="avg",
ceil_mode=True) pool_stride=stride,
ceil_mode=True)
else: else:
short = fluid.layers.pool2d(input=short, short = fluid.layers.pool2d(
pool_size=1, input=short,
pool_type="avg", pool_size=1,
pool_stride=1, pool_type="avg",
ceil_mode=True) pool_stride=1,
short = fluid.layers.conv2d(input=short, ceil_mode=True)
num_filters=planes*4, short = fluid.layers.conv2d(
filter_size=1, input=short,
stride=1, num_filters=planes * 4,
padding=0, filter_size=1,
groups=1, stride=1,
act=None, padding=0,
param_attr=ParamAttr(name=name+"_weights", initializer=MSRA()), groups=1,
bias_attr=False) act=None,
param_attr=ParamAttr(
name=name + "_weights", initializer=MSRA()),
bias_attr=False)
else: else:
short = fluid.layers.conv2d(input=short, short = fluid.layers.conv2d(
num_filters=planes*4, input=short,
filter_size=1, num_filters=planes * 4,
stride=stride, filter_size=1,
param_attr=ParamAttr(name=name+"_shortcut_weights", initializer=MSRA()), stride=stride,
bias_attr=False) param_attr=ParamAttr(
name=name + "_shortcut_weights", initializer=MSRA()),
short = fluid.layers.batch_norm(input=short, bias_attr=False)
act=None,
param_attr=ParamAttr(name=name+"_shortcut_scale", short = fluid.layers.batch_norm(
regularizer=L2DecayRegularizer(regularization_coeff=self.bn_decay)), input=short,
bias_attr=ParamAttr(name=name+"_shortcut_offset", act=None,
regularizer=L2DecayRegularizer(regularization_coeff=self.bn_decay)), param_attr=ParamAttr(
moving_mean_name=name+"_shortcut_mean", name=name + "_shortcut_scale",
moving_variance_name=name+"_shortcut_variance") regularizer=L2DecayRegularizer(
regularization_coeff=self.bn_decay)),
bias_attr=ParamAttr(
name=name + "_shortcut_offset",
regularizer=L2DecayRegularizer(
regularization_coeff=self.bn_decay)),
moving_mean_name=name + "_shortcut_mean",
moving_variance_name=name + "_shortcut_variance")
return fluid.layers.elementwise_add(x=short, y=x, act="relu") return fluid.layers.elementwise_add(x=short, y=x, act="relu")
def resnest_layer(self, def resnest_layer(self,
x, x,
planes, planes,
blocks, blocks,
stride=1, stride=1,
dilation=1, dilation=1,
is_first=True, is_first=True,
name=None): name=None):
if dilation==1 or dilation==2: if dilation == 1 or dilation == 2:
x = self.bottleneck(x=x, x = self.bottleneck(
inplanes=self.inplanes, x=x,
planes=planes, inplanes=self.inplanes,
stride=stride, planes=planes,
radix=self.radix, stride=stride,
cardinality=self.cardinality, radix=self.radix,
bottleneck_width=self.bottleneck_width, cardinality=self.cardinality,
avd=self.avd, bottleneck_width=self.bottleneck_width,
avd_first=self.avd_first, avd=self.avd,
dilation=1, avd_first=self.avd_first,
is_first=is_first, dilation=1,
rectify_avg=self.rectify_avg, is_first=is_first,
last_gamma=self.last_gamma, rectify_avg=self.rectify_avg,
name=name+"_bottleneck_0") last_gamma=self.last_gamma,
elif dilation==4: name=name + "_bottleneck_0")
x = self.bottleneck(x=x, elif dilation == 4:
inplanes=self.inplanes, x = self.bottleneck(
planes=planes, x=x,
stride=stride, inplanes=self.inplanes,
radix=self.radix, planes=planes,
cardinality=self.cardinality, stride=stride,
bottleneck_width=self.bottleneck_width, radix=self.radix,
avd=self.avd, cardinality=self.cardinality,
avd_first=self.avd_first, bottleneck_width=self.bottleneck_width,
dilation=2, avd=self.avd,
is_first=is_first, avd_first=self.avd_first,
rectify_avg=self.rectify_avg, dilation=2,
last_gamma=self.last_gamma, is_first=is_first,
name=name+"_bottleneck_0") rectify_avg=self.rectify_avg,
last_gamma=self.last_gamma,
name=name + "_bottleneck_0")
else: else:
raise RuntimeError("=>unknown dilation size") raise RuntimeError("=>unknown dilation size")
self.inplanes = planes*4 self.inplanes = planes * 4
for i in range(1, blocks): for i in range(1, blocks):
name = name+"_bottleneck_"+str(i) name = name + "_bottleneck_" + str(i)
x = self.bottleneck(x=x, x = self.bottleneck(
inplanes=self.inplanes, x=x,
planes=planes, inplanes=self.inplanes,
radix=self.radix, planes=planes,
cardinality=self.cardinality, radix=self.radix,
bottleneck_width=self.bottleneck_width, cardinality=self.cardinality,
avd=self.avd, bottleneck_width=self.bottleneck_width,
avd_first=self.avd_first, avd=self.avd,
dilation=dilation, avd_first=self.avd_first,
rectify_avg=self.rectify_avg, dilation=dilation,
last_gamma=self.last_gamma, rectify_avg=self.rectify_avg,
name=name) last_gamma=self.last_gamma,
name=name)
return x return x
def ResNeSt50(**args): def ResNeSt50(**args):
model = ResNeSt(layers=[3,4,6,3], radix=2, groups=1, bottleneck_width=64, model = ResNeSt(
deep_stem=True, stem_width=32, avg_down=True, layers=[3, 4, 6, 3],
avd=True, avd_first=False, final_drop=0.0, **args) radix=2,
groups=1,
bottleneck_width=64,
deep_stem=True,
stem_width=32,
avg_down=True,
avd=True,
avd_first=False,
final_drop=0.0,
**args)
return model return model
def ResNeSt101(**args): def ResNeSt101(**args):
model = ResNeSt(layers=[3,4,23,3], radix=2, groups=1, bottleneck_width=64, model = ResNeSt(
deep_stem=True, stem_width=64, avg_down=True, layers=[3, 4, 23, 3],
avd=True, avd_first=False, final_drop=0.0, **args) radix=2,
groups=1,
bottleneck_width=64,
deep_stem=True,
stem_width=64,
avg_down=True,
avd=True,
avd_first=False,
final_drop=0.0,
**args)
return model return model
def ResNeSt200(**args): def ResNeSt200(**args):
model = ResNeSt(layers=[3,24,36,3], radix=2, groups=1, bottleneck_width=64, model = ResNeSt(
deep_stem=True, stem_width=64, avg_down=True, layers=[3, 24, 36, 3],
avd=True, avd_first=False, final_drop=0.2, **args) radix=2,
groups=1,
bottleneck_width=64,
deep_stem=True,
stem_width=64,
avg_down=True,
avd=True,
avd_first=False,
final_drop=0.2,
**args)
return model return model
def ResNeSt269(**args): def ResNeSt269(**args):
model = ResNeSt(layers=[3,30,48,8], radix=2, groups=1, bottleneck_width=64, model = ResNeSt(
deep_stem=True, stem_width=64, avg_down=True, layers=[3, 30, 48, 8],
avd=True, avd_first=False, final_drop=0.2, **args) radix=2,
groups=1,
bottleneck_width=64,
deep_stem=True,
stem_width=64,
avg_down=True,
avd=True,
avd_first=False,
final_drop=0.2,
**args)
return model return model
def ResNeSt50_fast_1s1x64d(**args): def ResNeSt50_fast_1s1x64d(**args):
model = ResNeSt(layers=[3,4,6,3], radix=1, groups=1, bottleneck_width=64, model = ResNeSt(
deep_stem=True, stem_width=32, avg_down=True, layers=[3, 4, 6, 3],
avd=True, avd_first=True, final_drop=0.0, **args) radix=1,
groups=1,
bottleneck_width=64,
deep_stem=True,
stem_width=32,
avg_down=True,
avd=True,
avd_first=True,
final_drop=0.0,
**args)
return model return model
def ResNeSt50_fast_2s1x64d(**args): def ResNeSt50_fast_2s1x64d(**args):
model = ResNeSt(layers=[3,4,6,3], radix=2, groups=1, bottleneck_width=64, model = ResNeSt(
deep_stem=True, stem_width=32, avg_down=True, layers=[3, 4, 6, 3],
avd=True, avd_first=True, final_drop=0.0, **args) radix=2,
groups=1,
bottleneck_width=64,
deep_stem=True,
stem_width=32,
avg_down=True,
avd=True,
avd_first=True,
final_drop=0.0,
**args)
return model return model
def ResNeSt50_fast_4s1x64d(**args): def ResNeSt50_fast_4s1x64d(**args):
model = ResNeSt(layers=[3,4,6,3], radix=2, groups=1, bottleneck_width=64, model = ResNeSt(
deep_stem=True, stem_width=32, avg_down=True, layers=[3, 4, 6, 3],
avd=True, avd_first=True, final_drop=0.0, **args) radix=2,
groups=1,
bottleneck_width=64,
deep_stem=True,
stem_width=32,
avg_down=True,
avd=True,
avd_first=True,
final_drop=0.0,
**args)
return model return model
def ResNeSt50_fast_1s2x40d(**args): def ResNeSt50_fast_1s2x40d(**args):
model = ResNeSt(layers=[3,4,6,3], radix=1, groups=2, bottleneck_width=40, model = ResNeSt(
deep_stem=True, stem_width=32, avg_down=True, layers=[3, 4, 6, 3],
avd=True, avd_first=True, final_drop=0.0, **args) radix=1,
groups=2,
bottleneck_width=40,
deep_stem=True,
stem_width=32,
avg_down=True,
avd=True,
avd_first=True,
final_drop=0.0,
**args)
return model return model
def ResNeSt50_fast_2s2x40d(**args): def ResNeSt50_fast_2s2x40d(**args):
model = ResNeSt(layers=[3,4,6,3], radix=2, groups=2, bottleneck_width=40, model = ResNeSt(
deep_stem=True, stem_width=32, avg_down=True, layers=[3, 4, 6, 3],
avd=True, avd_first=True, final_drop=0.0, **args) radix=2,
groups=2,
bottleneck_width=40,
deep_stem=True,
stem_width=32,
avg_down=True,
avd=True,
avd_first=True,
final_drop=0.0,
**args)
return model return model
def ResNeSt50_fast_4s2x40d(**args): def ResNeSt50_fast_4s2x40d(**args):
model = ResNeSt(layers=[3,4,6,3], radix=4, groups=2, bottleneck_width=40, model = ResNeSt(
deep_stem=True, stem_width=32, avg_down=True, layers=[3, 4, 6, 3],
avd=True, avd_first=True, final_drop=0.0, **args) radix=4,
return model groups=2,
bottleneck_width=40,
def ResNeSt50_fast_1s4x24d(**args): deep_stem=True,
model = ResNeSt(layers=[3,4,6,3], radix=1, groups=4, bottleneck_width=24, stem_width=32,
deep_stem=True, stem_width=32, avg_down=True, avg_down=True,
avd=True, avd_first=True, final_drop=0.0, **args) avd=True,
avd_first=True,
final_drop=0.0,
**args)
return model return model
def ResNeSt50_fast_1s4x24d(**args):
model = ResNeSt(
layers=[3, 4, 6, 3],
radix=1,
groups=4,
bottleneck_width=24,
deep_stem=True,
stem_width=32,
avg_down=True,
avd=True,
avd_first=True,
final_drop=0.0,
**args)
return model
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或