<optgroup id="m04aa"><small id="m04aa"></small></optgroup><center id="m04aa"><wbr id="m04aa"></wbr></center><center id="m04aa"></center>
<optgroup id="m04aa"><small id="m04aa"></small></optgroup>
<noscript id="m04aa"></noscript>
<optgroup id="m04aa"></optgroup>
訂閱
糾錯
加入自媒體

Residual, BottleNeck, Linear BottleNeck, MBConv解釋

2022-03-29 10:36
磐創AI
關注

今天,我們將看到現代CNN架構中使用的不同模塊,如ResNet、MobileNet、EfficientNet,以及它們在PyTorch中的實現。

讓我們創建一個通用的conv-norm-act層

from functools import partial

from torch import nn

class ConvNormAct(nn.Sequential):

   def __init__(

       self,

       in_features: int,

       out_features: int,

       kernel_size: int,

       norm: nn.Module = nn.BatchNorm2d,

       act: nn.Module = nn.ReLU,

       **kwargs

   ):


       super().__init__(

           nn.Conv2d(

               in_features,

               out_features,

               kernel_size=kernel_size,

               padding=kernel_size // 2,

           ),

           norm(out_features),

           act(),

       )


Conv1X1BnReLU = partial(ConvNormAct, kernel_size=1)

Conv3X3BnReLU = partial(ConvNormAct, kernel_size=3)

import torch

x = torch.randn((1, 32, 56, 56))

Conv1X1BnReLU(32, 64)(x).shape

torch.Size([1, 64, 56, 56])

殘差連接殘差連接用于ResNet中,想法是將輸入添加到輸出中,輸出=層+輸入。下圖可能會幫助你將其可視化。但是,我的意思是它只是一個+運算符。殘差操作提高了梯度傳播的能力,允許有效地訓練具有100層以上的網絡。

在PyTorch中,我們可以輕松創建一個ResidualAdd層

from torch import nn

from torch import Tensor

class ResidualAdd(nn.Module):

   def __init__(self, block: nn.Module):

       super().__init__()

       self.block = block
       

   def forward(self, x: Tensor) -> Tensor:

       res = x

       x = self.block(x)

       x += res

       return x
   

ResidualAdd(

   nn.Conv2d(32, 32, kernel_size=1)

)(x).shape


shortcut

有時你的殘差沒有相同的輸出維度,所以我們不能添加它們。我們可以使用shortcut中的卷積投射輸入,以匹配輸出特征:

from typing import Optional


class ResidualAdd(nn.Module):

   def __init__(self, block: nn.Module, shortcut: Optional[nn.Module] = None):

       super().__init__()

       self.block = block

       self.shortcut = shortcut
       

   def forward(self, x: Tensor) -> Tensor:

       res = x

       x = self.block(x)

       if self.shortcut:

           res = self.shortcut(res)

       x += res

       return x


ResidualAdd(

   nn.Conv2d(32, 64, kernel_size=1),

   shortcut=nn.Conv2d(32, 64, kernel_size=1)

)(x).shape


BottleNeck Blocks

在圖像識別的深度殘差學習中引入了Bottlenecks。Bottlenecks塊接受大小為BxCxHxW的輸入,它首先使用1x1 卷積將其變為BxC/rxHxW,然后應用3x3 卷積,最后將輸出重新映射到與輸入相同的特征維度BxCxHxW,然后再次使用1x1卷積。這比使用三個3x3卷積更快。

因為首先減少了輸入,所以我們稱之為“Bottlenecks”。下圖顯示了該塊,我們在原始實現中使用了r=4

前兩個卷積之后是batchnorm和一個非線性激活層,而最后一個非線性層在加法后應用。

在PyTorch中為:

from torch import nn

class BottleNeck(nn.Sequential):

   def __init__(self, in_features: int, out_features: int, reduction: int = 4):

       reduced_features = out_features // reduction

       super().__init__(

           nn.Sequential(

               ResidualAdd(

                   nn.Sequential(

                       # wide -> narrow

                       Conv1X1BnReLU(in_features, reduced_features),

                       # narrow -> narrow

                       Conv3X3BnReLU(reduced_features, reduced_features),

                       # narrow -> wide

                       Conv1X1BnReLU(reduced_features, out_features, act=nn.Identity),

                   ),

                   shortcut=Conv1X1BnReLU(in_features, out_features)

                   if in_features 。 out_features

                   else None,

               ),

               nn.ReLU(),

           )

       )
       

BottleNeck(32, 64)(x).shape

請注意,僅當輸入和輸出特征不同時,我們才應用shortcut。

在實踐中,當我們希望減小空間維數時,在卷積中使用stride=2。

Linear BottleNecks

MobileNet V2中引入了Linear Bottleneck。Linear BottleNecks是沒有激活函數的Bottlenecks塊。

在論文的第3.2節中,他們詳細討論了為什么在輸出之前存在非線性會損害性能。簡而言之,非線性函數ReLU在<0時設為0會導致破壞信息。因此,在Bottlenecks中刪除nn.ReLU你就可以擁有Linear BottleNecks。

倒殘差

MobileNet V2中再次引入了倒殘差。

倒殘差塊是反向的Bottlenecks層。它們通過第一次卷積擴展特征,而不是減少特征。

下圖應該可以清楚地說明這一點

我們從BxCxHxW到->BxCxHxW->BxCxHxW->BxCxHxW,其中e是膨脹率,它被設置為4。而不是像在正常的Bottlenecks區那樣變寬->變窄->變寬,而是相反,變窄->變寬->變窄。

在PyTorch中,實現如下

class InvertedResidual(nn.Sequential):

   def __init__(self, in_features: int, out_features: int, expansion: int = 4):

       expanded_features = in_features * expansion

       super().__init__(

           nn.Sequential(

               ResidualAdd(

                   nn.Sequential(

                      # narrow -> wide

                       Conv1X1BnReLU(in_features, expanded_features),

                       # wide -> wide

                       Conv3X3BnReLU(expanded_features, expanded_features),

                       # wide -> narrow

                       Conv1X1BnReLU(expanded_features, out_features, act=nn.Identity),

                   ),

                   shortcut=Conv1X1BnReLU(in_features, out_features)

                   if in_features 。 out_features

                   else None,

               ),

               nn.ReLU(),

           )

       )
       InvertedResidual(32, 64)(x).shape


在MobileNet中,只有當輸入和輸出特征匹配時,才會應用殘差連接

class MobileNetLikeBlock(nn.Sequential):

   def __init__(self, in_features: int, out_features: int, expansion: int = 4):

       # use ResidualAdd if features match, otherwise a normal Sequential

       residual = ResidualAdd if in_features == out_features else nn.Sequential

       expanded_features = in_features * expansion

       super().__init__(

           nn.Sequential(

              residual(

                   nn.Sequential(

                       # narrow -> wide

                       Conv1X1BnReLU(in_features, expanded_features),

                       # wide -> wide

                       Conv3X3BnReLU(expanded_features, expanded_features),

                       # wide -> narrow

                       Conv1X1BnReLU(expanded_features, out_features, act=nn.Identity),

                   ),

               ),

               nn.ReLU(),

           )

       )
       MobileNetLikeBlock(32, 64)(x).shape

MobileNetLikeBlock(32, 32)(x).shape


MBConv

MobileNet V2的構建塊被稱為MBConv。MBConv是具有深度可分離卷積的倒殘差的Linear BottleNecks層。

深度可分離卷積

深度可分離卷積采用一種技巧,將一個正常的3x3卷積夾在兩個卷積中,以減少參數數量。

第一個對每個輸入的通道應用單個3x3濾波器,另一個對所有通道應用1x1濾波器。

這與正常的3x3卷積相同,但你節省了參數。

然而它比我們現有硬件上的普通3x3慢得多。

下圖顯示了這個想法

通道中的不同顏色表示每個通道應用的單個過濾器

PyTorch中:

class DepthWiseSeparableConv(nn.Sequential):

   def __init__(self, in_features: int, out_features: int):

       super().__init__(

           nn.Conv2d(in_features, in_features, kernel_size=3, groups=in_features),

           nn.Conv2d(in_features, out_features, kernel_size=1)

       )
        DepthWiseSeparableConv(32, 64)(x).shape


第一次卷積通常稱為depth,而第二次卷積稱為point。讓我們統計參數量

sum(p.numel() for p in DepthWiseSeparableConv(32, 64).parameters() if p.requires_grad) 

輸出:2432

讓我們看一個普通的Conv2d

sum(p.numel() for p in nn.Conv2d(32, 64, kernel_size=3).parameters() if p.requires_grad)

輸出:18496

有很大的區別

實現MBConv

那么,讓我們創建一個完整的MBConv。

MBConv有幾個重要的細節,標準化應用于深度和點卷積,非線性僅應用于深度卷積(Linear Bottlenecks)。

class MBConv(nn.Sequential):

   def __init__(self, in_features: int, out_features: int, expansion: int = 4):

       residual = ResidualAdd if in_features == out_features else nn.Sequential

       expanded_features = in_features * expansion
       

       super().__init__(

           nn.Sequential(

               residual(

                   nn.Sequential(

                      # narrow -> wide

                       Conv1X1BnReLU(in_features, 

                                     expanded_features,

                                     act=nn.ReLU6

                                    ),
                       

                       # wide -> wide

                       Conv3X3BnReLU(expanded_features, 

                                     expanded_features, 

                                     groups=expanded_features,

                                     act=nn.ReLU6

                                    ),
                       

                       # here you can apply SE

                       # wide -> narrow

                       Conv1X1BnReLU(expanded_features, out_features, act=nn.Identity),

                   ),

               ),

               nn.ReLU(),

           )

       )
       MBConv(32, 64)(x).shape


Fused MBConv

EfficientNetV2中引入了融合倒殘差

所以基本上,由于深度卷積比較慢,他們將第一個和第二個卷積融合在一個3x3的卷積中(第3.2節)。

       class FusedMBConv(nn.Sequential):

   def __init__(self, in_features: int, out_features: int, expansion: int = 4):

       residual = ResidualAdd if in_features == out_features else nn.Sequential

       expanded_features = in_features * expansion

       super().__init__(

           nn.Sequential(

               residual(

                   nn.Sequential(

                       Conv3X3BnReLU(in_features, 

                                     expanded_features, 

                                     act=nn.ReLU6

                                    ),

                       # here you can apply SE

                       # wide -> narrow

                       Conv1X1BnReLU(expanded_features, out_features, act=nn.Identity),

                   ),

               ),

               nn.ReLU(),

           )

       )
       MBConv(32, 64)(x).shape

結論

現在你應該知道所有這些塊之間的區別以及它們背后的原因了!

       原文標題 : Residual, BottleNeck, Linear BottleNeck, MBConv解釋

聲明: 本文由入駐維科號的作者撰寫,觀點僅代表作者本人,不代表OFweek立場。如有侵權或其他問題,請聯系舉報。

發表評論

0條評論,0人參與

請輸入評論內容...

請輸入評論/評論長度6~500個字

您提交的評論過于頻繁,請輸入驗證碼繼續

暫無評論

暫無評論

人工智能 獵頭職位 更多
掃碼關注公眾號
OFweek人工智能網
獲取更多精彩內容
文章糾錯
x
*文字標題:
*糾錯內容:
聯系郵箱:
*驗 證 碼:

粵公網安備 44030502002758號

太大太粗太爽免费视频
<optgroup id="m04aa"><small id="m04aa"></small></optgroup><center id="m04aa"><wbr id="m04aa"></wbr></center><center id="m04aa"></center>
<optgroup id="m04aa"><small id="m04aa"></small></optgroup>
<noscript id="m04aa"></noscript>
<optgroup id="m04aa"></optgroup>