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

1. 對輸入圖像進行拼接

2. 擴大kernel-size

3. 減少激活層和規范化層

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

1、簡介

1. Transformer塊本身已經是一個復合設計

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

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

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

• 最后，受最近工作的啟發，作者注意到減少規范化層和激活函數的數量有利于out-of-distribution魯棒性；同時，由于使用的規范化層較少，訓練速度可能會加快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，它包含具有不同紋理和局部圖像統計的ImageNet對象類的自然呈現；

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

2.4、Training Recipe

2.5、Baseline Results

3、COMPONENT DIAGNOSIS

3.1、PATCHIFY STEM

3.2、LARGE KERNEL SIZE

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

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

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

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

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

3.3、減少激活層和規范化層

4、組件組合

5、知識蒸餾

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

令人驚訝的是，當模型角色切換時，學生模型DeiT-S在一系列魯棒性基準上顯著優于教師模型ResNet-50，從而得出結論，實現DeiT良好魯棒性的關鍵在于其架構，因此不能通過知識蒸餾將其轉移到ResNet。

6、更大的模型

7、更多STEM實驗

8、與其他模型的比較

9、重復實驗

10、Imagenet評估

11、結構化重參

12、總結

13、參考

14、Robust ResNet的實現

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