코딩도상국

글의 가독성을 위해 아래 링크에 다시 정리함.

https://blog.naver.com/younjung1996/223413266165

안녕하세요. 오늘은 CNN에서 Depth-wise Separable Convolution에 대해 이야기해보겠습니다. 

Depth-wise separable Convolution을 가장 잘 표현한 그림이라고 생각합니다.

하지만 CNN에 대해 자세한 이해가 없으면 이 그림을 보더라도 이해가 잘 가지 않습니다. 

위 그림을 이해하기 위해서는 Standard(일반) Convolution을 정확히 파악해야 합니다. 

위 gif는 제 PPT 내용을 짜집어서 Standard Convolution 연산을 설명한 것입니다. 

기본적으로 하나의 Convolution을 통과하면 하나의 Feature Map(Activation Map)이 생성됩니다. 

( pytorch에서 out_channels을 통해 Feature Map의 개수를 정할 수 있습니다. )

이때 Feature Map 한 개를 생성하는데 Kernel Size x Kernel Size x Input Channel(입력 이미지 개수)의 Parameter가 필요합니다.

1. Standard Convolution vs Depth-wise Convolution

(색으로 비교하시면서 보십시오. )

하나의 Feature Map = Kernel Size x Kernel Size x 3

반면, Depth-wise은 아래와 같습니다.

차이를 아시겠나요? 

Depth-wise Convolution은 한 번 통과하면, 하나로 병합되지 않고, (R, G, B)가 각각 Feature Map이 됩니다. 

3 x Feature Map = Kernel Size x Kernel Size x 3

정리하게 되면,

하나의 Feature Map = Kernel Size x Kernel Size

두 개를 논문 Figure로 비교하면, 

 Depth-wise Convolution에서 연산량이 Input Channel 만큼 연산량이 줄어듭니다. 

2. Separable Convolution

Separable Convolution은 Point-wise Convolution 입니다.

Point-wise Convolution는 1x1 Convolution입니다. 

coding-yoon.tistory.com/116

1x1 Convolution의 역할을 자세히 알고 싶으시다면 위 글을 참고하시기 바랍니다. 

1x1 Convolution은 두 가지 특성을 가지고 있습니다 .

(1) 공간적인 특성을 가지고 있지 않다.

(2) 연산량이 가장 적게 필요로 하기 때문에, Feature Map 개수를 조절할 때 사용된다. 

3. Depth-wise Separable Convolution

(2) Pointwise Convolution에서 BottleNeck구조를 이해하셨으면, 바로 감이 오실 겁니다. 

BottleNeck의 구조 핵심은 연산량이 높은 곳은 최대한 Feature Map을 적게 생성하고, 연산량이 낮은 곳에서 Feature Map을 가지고 노는 것입니다. 

Depth-wise Convolution이 연산량이 적다 하더라도, Point-wise Convolution에 비하면 연산량이 굉장히 많은 편입니다. 

Depth-wise Convolution에서 Feature Map을 최대한 적게 뽑아내고, Point-wise Convolution에서 Feature Map을 필요한 만큼 뽑아냅니다.

3. vs Depth-wise Separable Convolution

두 식을 정리하면, 최종적으로 곱셈이 덧셈으로 바뀌게 됩니다. 

보통 Kernel Size보다 Output Channel이 훨씬 크기 때문에 계산해보면 약 Kernel size 제곱만큼의 차이가 발생합니다. 

이를 Pytorch로 구현하는 방법은 간단합니다. 

class depthwise_separable_conv(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(depthwise_seperable_conv, self).__init__()
        self.depthwise = nn.Conv2d(input_dim, input_dim, kernel_size=3, padding=1,
                                                              groups=input_dim)
        self.pointwise = nn.Conv2d(input_dim, output_dim, kernel_size=1)

    def forward(self, x):
        x = self.depthwise(x)
        x = self.pointwise(x)
        
       return x

Convolution에서 groups라는 인자가 있습니다. 

말 그대로 Input Channel을 얼마만큼 그룹 지어서 출력할지 정하는 인자입니다. 

 Group을 최대로 지으면, 결국 서로 각각의 독립적인 계산을 하게 됩니다. 

아래 Pytorch Document를 참고하시면 좋습니다. 

pytorch.org/docs/stable/generated/torch.nn.Conv2d.html?highlight=conv2d#torch.nn.Conv2d

글의 가독성을 위해 아래 링크에 정리해둠.

https://blog.naver.com/younjung1996/223413266165

안녕하세요. 

Google Coral에서 학습된 모델을 통해 추론을 할 수 있는 Coral Board & USB Accelator 가 있습니다. 

저는 Coral Board를 사용하지 않고, 라즈베리파이4에 USB Accelator를 연결하여 사용할 생각입니다. 

딥러닝을 위해 나온 제품이라 할지라도 아직 부족한 부분이 많습니다.

이런 고성능 환경이 아닌 곳에서도 학습하고, 추론할 수 있는 모바일 넷(Mobile Net)이 개발되었습니다. 

그 중 Mobile Net의 Architecture에서 Depthwise Separable Convolution에 대해 이야기하겠습니다. 

Depthwise separable Convoltion은 Parameter를 줄임으로, 연산량을 줄이고, 속도를 높이는 기법입니다. 

https://hichoe95.tistory.com/48

Depthwise Separable Convolution = Depthwise Convolution + Pointwise Convolution

아마 Depthwise Separable Convolution을 공부하실 때 위 그림을 가장 많이 보셨을겁니다.

Depthwise Convolution으로 채널간 Spartial Correlations을 고려하여 ~ 각각 독립적으로 패턴을 파악하고 ~ 

Pointwise Convolution으로 Cross Channel Correlations로 채널을 조절할 수 있는 ~ 블라블라

위 블로그 분께서 굉장히 정리를 잘해주셨습니다.

그럼 저의 글의 목적은 무엇이냐.

Standard Convolution과 Depthwise Separable Covolution를 pytorch로 구현하여 정말로 파라미터 수와 연산량이 줄어드는지 결과값을 눈으로 확인하는 것입니다.

1. Standard Convolution

Convolution = K * K * C * M

k : Kernel ( 3으로 가정)

c : intput_dimension (channel ) (100으로 가정)

m : output_dimension (activation map) (1000으로 가정)

standard_convolution = nn.Conv2d(in_channels=100, out_channels=1000, kernel_size=3, bias=False)

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 1000, 15, 15]         900,000
================================================================
Total params: 900,000
Trainable params: 900,000
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.11
Forward/backward pass size (MB): 1.72
Params size (MB): 3.43
Estimated Total Size (MB): 5.26
----------------------------------------------------------------

2. Depth-wise Convolution

Depthwise Convolutuon = K * K * C

k : Kernel ( 3으로 가정)

c : intput_dimension (channel ) (100으로 가정)

m : output_dimension (activation map) (1000으로 가정)

depthwise_convolution = nn.Conv2d(in_channels=100, out_channels=1000, kernel_size=3, groups=100,bias=False)

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1          [-1, 100, 15, 15]             900
================================================================
Total params: 900
Trainable params: 900
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.11
Forward/backward pass size (MB): 0.17
Params size (MB): 0.00
Estimated Total Size (MB): 0.29
----------------------------------------------------------------

3. Point-wise Convolution ( 1 x 1 Convolution )

Pointwise Convolutuon = C * M

k : Kernel ( 3으로 가정)

c : intput_dimension (channel ) (100으로 가정)

m : output_dimension (activation map) (1000으로 가정)

pointwise_convolution = nn.Conv2d(in_channels=100, out_channels=1000, kernel_size=1, bias=False)

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 1000, 17, 17]         100,000
================================================================
Total params: 100,000
Trainable params: 100,000
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.11
Forward/backward pass size (MB): 2.20
Params size (MB): 0.38
Estimated Total Size (MB): 2.70
----------------------------------------------------------------

4. Depthwise Separable Convolution 

Depthwise Separable Convolution = K * K * C + C * M = C( K * K + M )

k : Kernel ( 3으로 가정)

c : intput_dimension (channel ) (100으로 가정)

m : output_dimension (activation map) (1000으로 가정)

depthwise_separable_convolution = nn.Sequential(
    nn.Conv2d(in_channels=100,
              out_channels=100,
              kernel_size=3,
              groups=100,
              bias=False),

    nn.Conv2d(in_channels=100,
              out_channels=1000,
              kernel_size=1,
              bias=False)
)

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1          [-1, 100, 15, 15]             900
            Conv2d-2         [-1, 1000, 15, 15]         100,000
================================================================
Total params: 100,900
Trainable params: 100,900
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.11
Forward/backward pass size (MB): 1.89
Params size (MB): 0.38
Estimated Total Size (MB): 2.38
----------------------------------------------------------------

Depthwise Separable Convolution = Depthwise Convolution + Pointwise Convolution ( 100900 = 100000 + 900 ) 

Standard Convolution Parameters = 900,000

Depthwise Separable Convolution Parameters = 100,900

=> 약 K(Kernel Size) 제곱의 차이

5. Kernel Size가 값이 굉장히 크다면... ( kerenl size == 7 )

Standard Convolution 

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 1000, 11, 11]       4,900,000
================================================================
Total params: 4,900,000
Trainable params: 4,900,000
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.11
Forward/backward pass size (MB): 0.92
Params size (MB): 18.69
Estimated Total Size (MB): 19.73
----------------------------------------------------------------

Depthwise separable Convolution 

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1          [-1, 100, 11, 11]           4,900
            Conv2d-2         [-1, 1000, 11, 11]         100,000
================================================================
Total params: 104,900
Trainable params: 104,900
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.11
Forward/backward pass size (MB): 1.02
Params size (MB): 0.40
Estimated Total Size (MB): 1.53
----------------------------------------------------------------

Kernel의 사이즈가 커질수록, 엄청난 파라미터 수의 감소를 보여주며, 곱셈을 덧셈으로 대체하기 때문에 연산이 굉장히 빨라집니다.

이러한 특징덕에 의해, Depthwise separable Convolution를 통한 Inception, Xception, mobile net 등 여러 논문에서 많이 등장합니다.