視覺Transformer最近的成功動搖了卷積神經(jīng)網(wǎng)絡(luò)（CNNs）在圖像識別領(lǐng)域十年來的長期主導(dǎo)地位。具體而言，就out-of-distribution樣本的魯棒性而言，最近的研究發(fā)現(xiàn)，無論不同的訓(xùn)練設(shè)置如何，Transformer本質(zhì)上都比神經(jīng)網(wǎng)絡(luò)更魯棒。此外，人們認(rèn)為Transformer的這種優(yōu)越性在很大程度上應(yīng)該歸功于它們類似Self-Attention的架構(gòu)本身。在本文中，作者通過仔細(xì)研究Transformer的設(shè)計來質(zhì)疑這種信念。作者的發(fā)現(xiàn)導(dǎo)致了3種高效的架構(gòu)設(shè)計，以提高魯棒性，但足夠簡單，可以在幾行代碼中實現(xiàn)，即：

1. 對輸入圖像進(jìn)行拼接

2. 擴(kuò)大kernel-size

3. 減少激活層和規(guī)范化層

將這些組件結(jié)合在一起，作者能夠構(gòu)建純粹的CNN架構(gòu)，而無需任何像Transformer一樣魯棒甚至比Transformer更魯棒的類似注意力的操作。作者希望這項工作能夠幫助社區(qū)更好地理解魯棒神經(jīng)架構(gòu)的設(shè)計。代碼：https://github.com/UCSC-VLAA/RobustCNN

1、簡介

1. Transformer塊本身已經(jīng)是一個復(fù)合設(shè)計

2. Transformer還包含許多其他層（例如，Patch嵌入層），魯棒性和Transformer的架構(gòu)元素之間的關(guān)系仍然令人困惑。

• 首先，將圖像拼接成不重疊的Patch可以顯著地提高out-of-distribution魯棒性；更有趣的是，關(guān)于Patch大小的選擇，作者發(fā)現(xiàn)越大越好；

• 其次，盡管應(yīng)用小卷積核是一種流行的設(shè)計方法，但作者觀察到，采用更大的卷積核（例如，從3×3到7×7，甚至到11×11）對于確保out-of-distribution樣本的模型魯棒性是必要的；

• 最后，受最近工作的啟發(fā)，作者注意到減少規(guī)范化層和激活函數(shù)的數(shù)量有利于out-of-distribution魯棒性；同時，由于使用的規(guī)范化層較少，訓(xùn)練速度可能會加快23%。

2、SETTINGS

2.1、CNN Block Instantiations

1. 第1個Block是Depth-wise ResNet Bottleneck block，其中3×3卷積層被3×3深度卷積層取代；

2. 第2個Block是Inverted Depth-wise ResNet Bottleneck block，其中隱藏維度是輸入維度的4倍；

3. 第3個Block基于第2個Block，深度卷積層在ConvNeXT中的位置向上移動；

4. 基于第2個Block，第4 Block向下移動深度卷積層的位置。

2.2、Computational Cost

2.3、Robustness Benchmarks

1. Stylized-ImageNet，它包含具有形狀-紋理沖突線索的合成圖像；

2. ImageNet-C，具有各種常見的圖像損壞；

3. ImageNet-R，它包含具有不同紋理和局部圖像統(tǒng)計的ImageNet對象類的自然呈現(xiàn)；

4. ImageNet Sketch，其中包括在線收集的相同ImageNet類的草圖圖像。

2.4、Training Recipe

2.5、Baseline Results

3、COMPONENT DIAGNOSIS

3.1、PATCHIFY STEM

3.2、LARGE KERNEL SIZE

在本節(jié)中，作者旨在通過增加深度卷積層的內(nèi) kernel-size 來模擬Self-Attention塊的行為。如圖3所示，作者對不同大小的Kernel進(jìn)行了實驗，包括5、7、9、11和13，并在不同的魯棒性基準(zhǔn)上評估了它們的性能。作者的研究結(jié)果表明，較大的 kernel-size 通常會帶來更好的clean精度和更強(qiáng)的魯棒性。盡管如此，作者也觀察到，當(dāng) kernel-size 變得太大時，性能增益會逐漸飽和。

值得注意的是，使用具有較大Kernel的（標(biāo)準(zhǔn)）卷積將導(dǎo)致計算量的顯著增加。例如，如果作者直接將ResNet50中的 kernel-size 從3更改為5，則生成的模型的總FLOP將為7.4G，這比Transformer的對應(yīng)模型大得多。

然而，在使用深度卷積層的情況下，將內(nèi) kernel-size 從3增加到13通常只會使FLOP增加0.3G，與DeiT-S（4.6G）的FLOP相比相對較小。

這里唯一的例外情況是ResNet-Inverted-DW：由于其Inverted Bottleneck設(shè)計中的大通道尺寸，將 kernel-size 從3增加到13帶來了1.4G FLOP的增加，這在某種程度上是一個不公平的比較。順便說一句，使用具有大Patchvsize的Patch Stem可以減輕大 kernel-size 所產(chǎn)生的額外計算成本。

因此，作者的最終模型仍將處于與DeiT-S相同的規(guī)模。對于具有多個擬議設(shè)計的模型。

3.3、減少激活層和規(guī)范化層

4、組件組合

5、知識蒸餾

知識蒸餾是一種通過轉(zhuǎn)移更強(qiáng)的教師模型的知識來訓(xùn)練能力較弱的學(xué)生模型的技術(shù)。通常情況下，學(xué)生模型可以通過知識蒸餾獲得與教師模型相似甚至更好的性能。然而，直接應(yīng)用知識蒸餾讓ResNet-50（學(xué)生模型）向DeiT-S（教師模型）學(xué)習(xí)在增強(qiáng)魯棒性方面效果較差。

令人驚訝的是，當(dāng)模型角色切換時，學(xué)生模型DeiT-S在一系列魯棒性基準(zhǔn)上顯著優(yōu)于教師模型ResNet-50，從而得出結(jié)論，實現(xiàn)DeiT良好魯棒性的關(guān)鍵在于其架構(gòu)，因此不能通過知識蒸餾將其轉(zhuǎn)移到ResNet。

6、更大的模型

7、更多STEM實驗

8、與其他模型的比較

9、重復(fù)實驗

10、Imagenet評估

11、結(jié)構(gòu)化重參

12、總結(jié)

13、參考

14、Robust ResNet的實現(xiàn)

复制fromcollectionsimportOrderedDict
fromfunctoolsimportpartial

importtorch
importtorch.nnasnn
fromtimm.dataimportIMAGENET_DEFAULT_MEAN,IMAGENET_DEFAULT_STD
from.helpersimportbuild_model_with_cfg
from.layersimportSelectAdaptivePool2d,AvgPool2dSame
from.layersimportRobustResNetDWBlock,RobustResNetDWInvertedBlock,RobustResNetDWUpInvertedBlock,RobustResNetDWDownInvertedBlock
from.registryimportregister_model


__all__=['RobustResNet']#model_registrywilladdeachentrypointfntothis


def_cfg(url='',**kwargs):
return{
'url':url,
'num_classes':1000,'input_size':(3,224,224),'pool_size':(7,7),
'crop_pct':0.875,'interpolation':'bicubic',
'mean':IMAGENET_DEFAULT_MEAN,'std':IMAGENET_DEFAULT_STD,
'first_conv':'stem.0','classifier':'head.fc',
**kwargs
}


default_cfgs=dict(
small=_cfg(),
base=_cfg(),
)


defget_padding(kernel_size,stride,dilation=1):
padding=((stride-1)+dilation*(kernel_size-1))//2
returnpadding


defdownsample_conv(
in_channels,out_channels,kernel_size,stride=1,dilation=1,first_dilation=None,norm_layer=None):
norm_layer=norm_layerornn.BatchNorm2d
kernel_size=1ifstride==1anddilation==1elsekernel_size
first_dilation=(first_dilationordilation)ifkernel_size>1else1
p=get_padding(kernel_size,stride,first_dilation)

returnnn.Sequential(*[
nn.Conv2d(
in_channels,out_channels,kernel_size,stride=stride,padding=p,dilation=first_dilation,bias=True),
norm_layer(out_channels)
])


defdownsample_avg(
in_channels,out_channels,kernel_size,stride=1,dilation=1,first_dilation=None,norm_layer=None):
norm_layer=norm_layerornn.BatchNorm2d
avg_stride=strideifdilation==1else1
ifstride==1anddilation==1:
pool=nn.Identity()
else:
avg_pool_fn=AvgPool2dSameifavg_stride==1anddilation>1elsenn.AvgPool2d
pool=avg_pool_fn(2,avg_stride,ceil_mode=True,count_include_pad=False)

returnnn.Sequential(*[
pool,
nn.Conv2d(in_channels,out_channels,1,stride=1,padding=0,bias=True),
norm_layer(out_channels)
])


classStage(nn.Module):
def__init__(
self,block_fn,in_chs,chs,stride=2,depth=2,dp_rates=None,layer_scale_init_value=1.0,
norm_layer=nn.BatchNorm2d,act_layer=partial(nn.ReLU,partial=True),
avg_down=False,down_kernel_size=1,mlp_ratio=4.,inverted=False,**kwargs):
super().__init__()

blocks=[]
dp_rates=dp_ratesor[0.]*depth
forblock_idxinrange(depth):
stride_block_idx=depth-1ifblock_fn==RobustResNetDWDownInvertedBlockelse0
current_stride=strideifblock_idx==stride_block_idxelse1

downsample=None
ifinverted:
ifin_chs!=chsorcurrent_stride>1:
down_kwargs=dict(
in_channels=in_chs,out_channels=chs,kernel_size=down_kernel_size,
stride=current_stride,norm_layer=norm_layer)
downsample=downsample_avg(**down_kwargs)ifavg_downelsedownsample_conv(**down_kwargs)
else:
ifin_chs!=int(mlp_ratio*chs)orcurrent_stride>1:
down_kwargs=dict(
in_channels=in_chs,out_channels=int(mlp_ratio*chs),kernel_size=down_kernel_size,
stride=current_stride,norm_layer=norm_layer)
downsample=downsample_avg(**down_kwargs)ifavg_downelsedownsample_conv(**down_kwargs)
ifdownsampleisnotNone:
assertblock_idxin[0,depth-1]

blocks.append(block_fn(
indim=in_chs,dim=chs,drop_path=dp_rates[block_idx],layer_scale_init_value=layer_scale_init_value,
mlp_ratio=mlp_ratio,
norm_layer=norm_layer,act_layer=act_layer,
stride=current_stride,
downsample=downsample,
**kwargs,
))
in_chs=int(chs*mlp_ratio)ifnotinvertedelsechs

self.blocks=nn.Sequential(*blocks)

defforward(self,x):
x=self.blocks(x)
returnx


classRobustResNet(nn.Module):
#TODO:finishcommenthere
r"""RobustResNetDW
APyTorchimplof:

Args:
in_chans(int):Numberofinputimagechannels.Default:3
num_classes(int):Numberofclassesforclassificationhead.Default:1000
depths(tuple(int)):Numberofblocksateachstage.Default:[3,3,9,3]
dims(tuple(int)):Featuredimensionateachstage.Default:[96,192,384,768]
drop_rate(float):Headdropoutrate
drop_path_rate(float):Stochasticdepthrate.Default:0.
layer_scale_init_value(float):InitvalueforLayerScale.Default:1e-6.
head_init_scale(float):Initscalingvalueforclassifierweightsandbiases.Default:1.
"""

def__init__(
self,block_fn,in_chans=3,num_classes=1000,global_pool='avg',output_stride=32,
patch_size=16,stride_stage=(3,),
depths=(3,3,9,3),dims=(96,192,384,768),layer_scale_init_value=1e-6,
head_init_scale=1.,head_norm_first=False,
norm_layer=nn.BatchNorm2d,act_layer=partial(nn.ReLU,inplace=True),
drop_rate=0.,drop_path_rate=0.,mlp_ratio=4.,block_args=None,
):
super().__init__()
assertblock_fnin[RobustResNetDWBlock,RobustResNetDWInvertedBlock,RobustResNetDWUpInvertedBlock,RobustResNetDWDownInvertedBlock]
self.inverted=Trueifblock_fn!=RobustResNetDWBlockelseFalse
assertoutput_stride==32

self.num_classes=num_classes
self.drop_rate=drop_rate
self.feature_info=[]

block_args=block_argsordict()
print(f'usingblockargs:{block_args}')

assertpatch_size==16
self.stem=nn.Conv2d(in_chans,dims[0],kernel_size=patch_size,stride=patch_size)
curr_stride=patch_size

self.stages=nn.Sequential()
dp_rates=[x.tolist()forxintorch.linspace(0,drop_path_rate,sum(depths)).split(depths)]
prev_chs=dims[0]
stages=[]
#4featureresolutionstages,eachconsistingofmultipleresidualblocks
foriinrange(4):
stride=2ifiinstride_stageelse1
curr_stride*=stride
chs=dims[i]
stages.append(Stage(
block_fn,prev_chs,chs,stride=stride,
depth=depths[i],dp_rates=dp_rates[i],layer_scale_init_value=layer_scale_init_value,
norm_layer=norm_layer,act_layer=act_layer,mlp_ratio=mlp_ratio,
inverted=self.inverted,**block_args)
)
prev_chs=int(mlp_ratio*chs)ifnotself.invertedelsechs
self.feature_info+=[dict(num_chs=prev_chs,reduction=curr_stride,module=f'stages.{i}')]
self.stages=nn.Sequential(*stages)
assertcurr_stride==output_stride

self.num_features=prev_chs

self.norm_pre=nn.Identity()
self.head=nn.Sequential(OrderedDict([
('global_pool',SelectAdaptivePool2d(pool_type=global_pool)),
#('norm',norm_layer(self.num_features)),
('flatten',nn.Flatten(1)ifglobal_poolelsenn.Identity()),
('drop',nn.Dropout(self.drop_rate)),
('fc',nn.Linear(self.num_features,num_classes)ifnum_classes>0elsenn.Identity())
]))

self.resnet_init_weights()

defresnet_init_weights(self):
forn,minself.named_modules():
ifisinstance(m,nn.Conv2d):
nn.init.kaiming_normal_(m.weight,mode='fan_out',nonlinearity='relu')
nn.init.zeros_(m.bias)
elifisinstance(m,nn.BatchNorm2d):
nn.init.ones_(m.weight)
nn.init.zeros_(m.bias)

defget_classifier(self):
returnself.head.fc

defreset_classifier(self,num_classes=0,global_pool='avg'):
#pool->norm->fc
self.head=nn.Sequential(OrderedDict([
('global_pool',SelectAdaptivePool2d(pool_type=global_pool)),
('norm',self.head.norm),
('flatten',nn.Flatten(1)ifglobal_poolelsenn.Identity()),
('drop',nn.Dropout(self.drop_rate)),
('fc',nn.Linear(self.num_features,num_classes)ifnum_classes>0elsenn.Identity())
]))

defforward_features(self,x):
x=self.stem(x)
x=self.stages(x)
x=self.norm_pre(x)
returnx

defforward(self,x):
x=self.forward_features(x)
x=self.head(x)
returnx


def_create_robust_resnet(variant,pretrained=False,**kwargs):
model=build_model_with_cfg(
RobustResNet,variant,pretrained,
default_cfg=default_cfgs[variant],
feature_cfg=dict(out_indices=(0,1,2,3),flatten_sequential=True),
**kwargs)
returnmodel


@register_model
defrobust_resnet_dw_small(pretrained=False,**kwargs):
'''
4.49GFLOPsand38.6MParams
'''
assertnotpretrained,'nopretrainedmodels!'
model_args=dict(block_fn=RobustResNetDWBlock,depths=(3,4,12,3),dims=(96,192,384,768),
block_args=dict(kernel_size=11,padding=5),
patch_size=16,stride_stage=(3,),
norm_layer=nn.BatchNorm2d,act_layer=partial(nn.ReLU,inplace=True),
**kwargs)
model=_create_robust_resnet('small',pretrained=pretrained,**model_args)
returnmodel


@register_model
defrobust_resnet_inverted_dw_small(pretrained=False,**kwargs):
'''
4.59GFLOPsand33.6MParams
'''
assertnotpretrained,'nopretrainedmodels!'
model_args=dict(block_fn=RobustResNetDWInvertedBlock,depths=(3,4,14,3),dims=(96,192,384,768),
block_args=dict(kernel_size=7,padding=3),
patch_size=16,stride_stage=(3,),
norm_layer=nn.BatchNorm2d,act_layer=partial(nn.ReLU,inplace=True),
**kwargs)
model=_create_robust_resnet('small',pretrained=pretrained,**model_args)
returnmodel


@register_model
defrobust_resnet_up_inverted_dw_small(pretrained=False,**kwargs):
'''
4.43GFLOPsand34.4MParams
'''
assertnotpretrained,'nopretrainedmodels!'
model_args=dict(block_fn=RobustResNetDWUpInvertedBlock,depths=(3,4,14,3),dims=(96,192,384,768),
block_args=dict(kernel_size=11,padding=5),
patch_size=16,stride_stage=(3,),
norm_layer=nn.BatchNorm2d,act_layer=partial(nn.ReLU,inplace=True),
**kwargs)
model=_create_robust_resnet('small',pretrained=pretrained,**model_args)
returnmodel


@register_model
defrobust_resnet_down_inverted_dw_small(pretrained=False,**kwargs):
'''
4.55GFLOPsand24.3MParams
'''
assertnotpretrained,'nopretrainedmodels!'
model_args=dict(block_fn=RobustResNetDWDownInvertedBlock,depths=(3,4,15,3),dims=(96,192,384,768),
block_args=dict(kernel_size=11,padding=5),
patch_size=16,stride_stage=(2,),
norm_layer=nn.BatchNorm2d,act_layer=partial(nn.ReLU,inplace=True),
**kwargs)
model=_create_robust_resnet('small',pretrained=pretrained,**model_args)
returnmodel