반응형

안녕하세요.

 

원래 IT 기기에 관심이 많다 보니 사놓은 것들이 꽤 있습니다. 글 적는게 재미는 있지만, 아무래도 공부와 연구 관련된 것들에 대해서만 글을 쓰다보니 딱딱한 글만 있는 것 같습니다. 그래서 지금까지 제가 샀던 것들에 대해 모아서 리뷰하면 재밌을 것 같아 카테고리에 IT 리뷰를 추가했습니다.

 

원래 저는 팔찌와 샤오미 미밴드5를 같이 끼고 다닙니다. 

샤오미 미밴드

샤오미 미밴드5가 문자, 카톡 등 휴대폰 알림 등을 확인할 수 있고, 특히 배터리가 일주일 이상 가니 많이 애용했습니다. 

 

갤럭시 파인 저는 요즘 갤럭시 워치에 관심을 가지고 있습니다.

 

갤럭시 워치4가 예약판매를 하고 있는 중이기에 솔직히 고민을 많이 했습니다. 왜냐면 타이젠 OS를 두고 웨어 OS로 전환해 최적화를 하였다는 소식이 들렸기 때문입니다. 디자인도 너무 이쁘고

 

하지만 30만원대인 가격을 보고 바로 포기했습니다. 있으면 좋지만 굳이 없어도 되는 것을 지금 사는 것은 불필요한 지출이였기 때문입니다. 

 

저 같은 경우는 잇섭님 유튜브를 항상 챙겨 보는 구독자로, 잇섭님이 Amazfit GTS2 mini를 소개하는 영상을 보고 처음 알게 되었습니다. 

 

그 때는 샤오미 미밴드를 끼고 있었기 때문에 별로 신경쓰지 않았지만, 워치를 끼고 싶어서 GTS2 mini를 사게 됐습니다.

 

GTS2 mini 같은 경우에는 워낙 유명한 제품이라, 제품 특징 같은 경우는 굳이 소개안하려고 합니다. 

 

Q10에서 7만원대에 나왔길래, 바로 할인 쿠폰 적용해서 6만원대에 구했습니다. 주문한지 삼일만에 왔습니다. 

GTS2 mini
언박싱

GTS2 mini를 키자마자 어플 다운로드로 연결하는 QR코드가 뜹니다.

QR코드
Zepp 어플
스마트폰과 워치 연결

연결되면 펌웨어 업그레이드 해주고, 설정은 자기 입 맛에 맞게 사용합니다. 원래 개발을 하는 입장에서 개발 환경이나 언어 업그레이드를 잘 안하려고 하지만, 이런 기계들은 바로바로 업그레이드!

 

착용샷!

 

찍는 도중 여자친구한테 카톡이 온걸 보니 잘 작동합니다.

기본 배경도 깔끔하고 괜찮습니다. 

3일 정도 사용해봤는데 저같은 경우에 만보기 이외에 기능들은 거의 꺼두기 때문에, 하루에 10% 정도 닳습니다. 

 

알림도 제대로 오고, 샤오미 미밴드를 쓰다가 워치로 가면 무겁지 않을까 걱정했는데 많이 가볍습니다.

 

다른 연구실 형님이 제 워치를 보고 순간 애플워치로 속더라구요. 애플워치 샀냐고... 아마 이 맛에 GTS2 mini 사나봅니다.

 

뭐 기능이야 예상했던대로 샤오미 미밴드랑 크게 다른 것이 없습니다. 

 

이 주정도 더 써보다가 제품에 하자가 있으면 그에 대해 리뷰 글을 더 적고, 없으면 쓰지 않겠습니다.

 

제품에 문제가 생겨서 글 쓰는 일이 없었으면 좋겠습니다. 

 


2주 리뷰

 

< 장점 >

 

연구실에서 2주 정도 사용했는데, 대부분이 애플워치 샀냐고 물어봄. 그래서 기분이 좋아짐.

 

배터리 부분이 가장 마음에 듬. 충전도 굉장히 빠르고.

 

필요 없는 기능들을 전부 끄고, 사용하니 일주일은 넘게 사용 가능함. 어차피 시간, 날씨, 알림 정도만 확인하는 정도로

 

샤오미 미밴드도 굉장히 좋은 제품이지만, 알림 같은게 바로바로 눈에 안들어지만, 디스플레이가 큰 만큼 확실히 눈에 글자들이 들어옴.

 

< 단점 >

 

다 마음에 들지만, 굳이 꼽자면 워치 페이스 종류가 부족함. 하지만 구글 스토어에서 gts2 watch face를 검색해서 외부 어플에서 워치 페이스를 받을 수 있으므로 큰 문제는 되지 않음. 

 

그리고 베젤 부분은 마음에 안들지만,, 못봐줄만큼 아니기에 사진 정도이므로 참고 바람.

 

갤럭시 워치가 삼성페이도 되고, OS 최적화가 돼었을 때까지 존버용으로 마음에 듭니다.

여름 휴가 스누피~

728x90
반응형
반응형

안녕하세요.  

 

오늘은 혼자 공부하는 파이썬(윤인성)을 리뷰하겠습니다.

 

가격 18,000원

요즘 인공지능/빅데이터 유행으로 파이썬이라는 언어가 뜨고 있습니다. 

 

그래서 아마 많은 사람들이 파이썬에 대해 유튜브나 구글에서 검색해 보셨을겁니다. 

 

저도 유튜브와 구글링을 통해 파이썬을 배웠습니다. 

 

손에 익을 때 쯤 파이썬을 체계적으로 공부하고 싶어 책을 구매했습니다.

 

1. 내 용

아마 프로그램 개발을 공부해보신 분이라면 책이 어떤 방향으로 나아갈 것인지 예상하실겁니다.

 

 

1-1. 시작

시작은 무엇을 공부할 것인지 대략적으로 소개합니다. 

 

비전공자들도 이해할 수 있게끔 그림을 보여주면서 설명합니다. 

 

1-2. 내용

 

코드를 보시면 아시겠지만, 상당히 간단한 코드로 설명합니다. 

 

1-3. 마무리

 지금까지 배운 내용을 정리합니다.

 

대부분의 프로그래밍 책과 같은 방향으로 나아갑니다.

 

 

2. 후 기 

만약, 저처럼 유튜브로 파이썬을 공부하시고 체계적으로 공부하고 싶으신 분들에게는 비추입니다. 

 

보시면, 아시겠지만 위 내용들은 충분히 구글에서 찾아서 공부할 수 있는 내용들입니다. 

 

조금 파이썬다운 코드나 고급적인 코드들은 제대로 보여주지 못하고 있습니다. 

 

하지만, 이것은 어디까지나 파이썬이나 프로그래밍에 배운 사람 한해서 해당합니다. 

 

쉬운 설명과 간단한 코드들로 처음 프로그래밍을 접한 사람들에게 할 수 있다는 마음을 주고, 충분히 혼자서도 할 수 있을 능력을 기르는데 포커스를 맞춘 것 같습니다.

 

무엇을 공부해야하고, 무엇을 모르는 사람들에게 전체적인 흐름을 느끼기에는 충분하다고 생각합니다. 

 

저도 클래스나 예외처리 등 가끔 필요하다 싶으면 찾아서 보곤 합니다. 

 

728x90
반응형
반응형

안녕하세요. 오늘은 Xception 리뷰 세번 째 시간입니다.

 

1. The Xception architecture

 

in particular the VGG-16 architecture , which is schematically similar to our proposed architecture 
in a few respects.

특히 VGG-16계층은 몇 가지 측면에서 Xception 계층과 개략적으로 유사합니다.

 

The Inception architecture family of convolutional neural networks, which first demonstrated the 
advantages of factoring convolutions into multiple branches operating successively on channels and then on 
space.

Inception 모듈이 여러가지 방향으로 채널과 공간에서 작동하는 장점을 소개하고 있다는 내용입니다.

 

Depthwise separable convolutions, which our proposed architecture is entirely based upon. ~~

앞 쪽에서 이야기한 Depthwise Separable Convolution의 연산량 감소로 인한 속도 증가의 장점을 소개하고
있습니다.

coding-yoon.tistory.com/77

 

[딥러닝] Depthwise Separable Covolution with Pytorch( feat. Convolution parameters VS Depthwise Separable Covolution paramet

안녕하세요. Google Coral에서 학습된 모델을 통해 추론을 할 수 있는 Coral Board & USB Accelator 가 있습니다. 저는 Coral Board를 사용하지 않고, 라즈베리파이4에 USB Accelator를 연결하여 사용할 생각입니..

coding-yoon.tistory.com

 

Residual connections, introduced by He et al. in [4], which our proposed architecture uses extensively.

Resnet에서 사용하는 Residual Connections

https://openaccess.thecvf.com/content_cvpr_2016/papers/He_Deep_Residual_Learning_CVPR_2016_paper.pdf

 

Residual Connections : BottleNeck (x)

Residual Connections를 짚고 넘어가자면, Resnet의 배경은 히든레이어가 증가함에 따라 학습이 더 잘되어야 하지만, 오히려 학습을 못하는 현상이 발생합니다. 이 현상이 vanishing/exploding gradients (기울기 손실) 문제입니다. Batch Normalization으로  어느정도 해결할 수 있지만, 근본적인 문제를 해결할 수 없습니다. 그래서 고안된 방법이 Residual Connection(mapping) 입니다. 이전의 값을 더해줌으로 기울기 손실을 방지하는 것입니다. 간단한 방법이지만 효과는 굉장히 좋습니다. 

 

dataset은 FastEval14K를 사용하였습니다. (299x299x3)

 

2. implemention

2-1 depthwise separable convolution

def depthwise_separable_conv(input_dim, output_dim):
   
    depthwise_convolution = nn.Conv2d(input_dim, input_dim, kernel_size=3, padding=1, groups=input_dim, bias=False)
    pointwise_convolution = nn.Conv2d(input_dim, output_dim, kernel_size=1, bias=False)
   
    model = nn.Sequential(
        depthwise_convolution,
        pointwise_convolution
       
    )
       
    return model

2-2 Entry flow

class entry_flow(nn.Module):
    def __init__(self):
        super(entry_flow, self).__init__()
       
        self.conv2d_init_1 = nn.Conv2d(in_channels = 3,
                                       out_channels = 32,
                                       kernel_size = 3,
                                       stride = 2,
                                      )
       
        self.conv2d_init_2 = nn.Conv2d(in_channels = 32,
                                       out_channels = 64,
                                       kernel_size = 3,
                                       stride = 1,
                                      )
       
       
        self.layer_1 = nn.Sequential(
            depthwise_separable_conv(input_dim = 64, output_dim = 128),
            nn.ReLU(),
            depthwise_separable_conv(input_dim = 128, output_dim = 128),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
           
        )
                                                             
        self.conv2d_1 = nn.Conv2d(in_channels = 64,
                                  out_channels = 128,
                                  kernel_size = 1,
                                  stride = 2
                                  )
       
        self.layer_2 = nn.Sequential(
            depthwise_separable_conv(input_dim = 128, output_dim = 256),
            nn.ReLU(),
            depthwise_separable_conv(input_dim = 256, output_dim = 256),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
           
        )
                                                             
        self.conv2d_2 = nn.Conv2d(in_channels = 128,
                                  out_channels = 256,
                                  kernel_size = 1,
                                  stride = 2
                                  )
       
        self.layer_3 = nn.Sequential(
            depthwise_separable_conv(input_dim = 256, output_dim = 728),
            nn.ReLU(),
            depthwise_separable_conv(input_dim = 728, output_dim = 728),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
           
        )
                                                             
        self.conv2d_3 = nn.Conv2d(in_channels = 256,
                                  out_channels = 728,
                                  kernel_size = 1,
                                  stride = 2
                                  )
       
        self.relu = nn.ReLU()
       
    def forward(self, x):
        x = self.conv2d_init_1(x)
        x = self.relu(x)
        x = self.conv2d_init_2(x)
        x = self.relu(x)
       
        output1_1 = self.layer_1(x)
        output1_2 = self.conv2d_1(x)
        output1_3 = output1_1 + output1_2
       
       
        output2_1 = self.layer_2(output1_3)
        output2_2 = self.conv2d_2(output1_3)
        output2_3 = output2_1 + output2_2
       
       
        output3_1 = self.layer_3(output2_3)
        output3_2 = self.conv2d_3(output2_3)
        output3_3 = output3_1 + output3_2
        y = output3_3
       
        return y

2-2 Middle flow

class middle_flow(nn.Module):
    def __init__(self):
        super(middle_flow, self).__init__()
       
        self.module_list = nn.ModuleList()
       
        layers = nn.Sequential(
                nn.ReLU(),
                depthwise_separable_conv(input_dim = 728, output_dim = 728),
                nn.ReLU(),
                depthwise_separable_conv(input_dim = 728, output_dim = 728),
                nn.ReLU(),
                depthwise_separable_conv(input_dim = 728, output_dim = 728)
            )
       
        for i in range(7):
            self.module_list.append(layers)
           
    def forward(self, x):
        for layer in self.module_list:
            x_temp = layer(x)
            x = x + x_temp
       
        return x

2-3 Exit flow

class exit_flow(nn.Module):
    def __init__(self, growth_rate=32):
        super(exit_flow, self).__init__()
       
        self.separable_network = nn.Sequential(
            nn.ReLU(),
            depthwise_separable_conv(input_dim = 728, output_dim = 728),
            nn.ReLU(),
            depthwise_separable_conv(input_dim = 728, output_dim = 1024),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        )
       
        self.conv2d_1 = nn.Conv2d(in_channels = 728,
                                  out_channels = 1024,
                                  kernel_size = 1,
                                  stride = 2
                                  )
       
        self.separable_conv_1 = depthwise_separable_conv(input_dim = 1024, output_dim = 1536)
        self.separable_conv_2 = depthwise_separable_conv(input_dim = 1536, output_dim = 2048)
       
        self.relu = nn.ReLU()
        self.avgpooling = nn.AdaptiveAvgPool2d((1))
       
        self.fc_layer = nn.Linear(2048, 10)
       
    def forward(self, x):
        output1_1 = self.separable_network(x)
        output1_2 = self.conv2d_1(x)
        output1_3 = output1_1 + output1_2
 
        y = self.separable_conv_1(output1_3)
        y = self.relu(y)
        y = self.separable_conv_2(y)
        y = self.relu(y)
        y = self.avgpooling(y)
       
        y = y.view(-1, 2048)
        y= self.fc_layer(y)
       
       
        return y

2-4 Xception

class Xception(nn.Module):
    def __init__(self):
        super(Xception, self).__init__()
        self.entry_flow = entry_flow()
        self.middle_flow = middle_flow()
        self.exit_flow = exit_flow()
       
       
       
    def forward(self, x):
        x = self.entry_flow(x)
        x = self.middle_flow(x)
        x = self.exit_flow(x)
       
        return x

 

3. Experiment result

 

다른 모델에 비해 높은 accuracy
연산량 감소
Residual Connection의 성능

4. Conclusions

Depthwise Separable Convolution이 Inception 모듈과 유사하지만, Standard Convolution 만큼 사용하기 쉽고, 높은 성능과 연산량 감소의 장점 때문에 CNN의 설계의 기초가 될 것으로 기대가 됩니다. Xception 논문 리뷰를 마치도록 하겠습니다. 첫 논문 리뷰인지라 말하고자 하는 내용을 명확하게 설명하지 못하였습니다. 혹시라도 보시다가 잘못된 부분이나 추가해야할 부분이 보이시면 피드백 주시면 감사하겠습니다.

728x90
반응형
반응형

 

 

 

https://openaccess.thecvf.com/content_cvpr_2017/papers/Chollet_Xception_Deep_Learning_CVPR_2017_paper.pdf

 

안녕하세요.

 

Xception 논문 리뷰 2회차입니다. 

 

1회차 논문리뷰로 An Extreme version of Inception module이 Depthwise Separable Convolution까지 소개했습니다.

 

아래 전 편의 글을 읽는 것을 추천드립니다.

 

https://coding-yoon.tistory.com/78?category=825914

 

[딥러닝 논문 리뷰] Xception: Deep Learning with Depthwise Separable Convolutions (feat.Pytorch)(1)

안녕하세요. 저번 Depthwise Separable Convolution 기법에 대해 글을 올렸습니다. 오늘은 이 기법을 사용한 Xception 논문에 대해 리뷰하도록 하겠습니다. https://openaccess.thecvf.com/content_cvpr_2017/html..

coding-yoon.tistory.com

 

An Extreme version of Inception module과 Depthwise Separable Convolution는 굉장히 비슷한 형태를 가지고 있습니다.

 

논문에서 소개하는 두 개의 차이점을 설명하고 있습니다.

 

Two minor differences between and “extreme” version of an Inception module and a depthwise separable 
convolution would be:

“extreme” version of an Inception module과 depthwise separable 
convolution의 두 가지 사소한 차이점은 다음과 같습니다.

 

 

 

1. Order(순서)

• The order of the operations: 
depthwise separable convolutions as usually implemented (e.g. in TensorFlow)perform first channel-wise 
spatial convolution and then perform 1x1 convolution, whereas Inception performs
the 1x1 convolution first.

Depthwise Separable Convolution : Depthwise Convolution(3x3, 5x5 ...), Pointwise Convolution 

An Extreme version of Inception module : Pointwise Convolution , Depthwise Convolution(3x3, 5x5 ...)

 

Convolution의 순서가 다르다고 합니다.

We argue that the first difference is unimportant, in particular because these operations are meant
to be used in a stacked setting.

 

스택 설정에서 사용되기 때문에 순서의 차이점은 중요하지 않다고 합니다.

 

 

 

2. Non-Linearity(비선형성)

• The presence or absence of a non-linearity after the first operation.
In Inception, both operations are followed by a ReLU non-linearity, however depthwise separable 
convolutions are usually implemented without non-linearities.

ReLU(비선형)의 유무.

 

Inception은 Convolution 수행이 후 ReLU가 붙는 반면, 

 

일반적으로 Depthwise Separable Convolution는 ReLU가 없이 구현됩니다. 

 

The second difference might matter, and we investigate it in the experimental section 
(in particular see figure 10).

 

ReLU의 유무는 중요하며, Figure 10에서 실험 결과를 보여줍니다.

 

Depthwise Separable Convolution에서 ReLU를 사용하지 않았을 때 더 높은 Accruacy를 보여줍니다.

 

It may be that the depth of the intermediate feature spaces on which spatial convolutions are applied 
is critical to the usefulness of the non-linearity:

 for deep feature spaces (e.g. those found in Inception modules) the non-linearity is helpful, 
 but for shallow ones (e.g. the 1-channel deep feature spaces of depthwise separable convolutions) it becomes harmful, 
 possibly due to a loss of information.

 

깊은 특징 공간의 경우, ReLU가 도움이 되지만  얕은 공간( 1x1 Convolution )에서는 ReLU에 의해 정보 손실이 생길 수 있기 때문에 사용하지 않는 것이 좋다는 결과입니다.

 

다음 글은 Xception의 Architecture에 대해 설명하고, Pytorch로 구현함으로 글을 Xception 논문 리뷰를 마치도록 하겠습니다. 피드백주시면 감사하겠습니다.

728x90
반응형
반응형

안녕하세요. 저번 Depthwise Separable Convolution 기법에 대해 글을 올렸습니다.

 

오늘은 이 기법을 사용한 Xception 논문에 대해 리뷰하도록 하겠습니다. 

 

https://openaccess.thecvf.com/content_cvpr_2017/html/Chollet_Xception_Deep_Learning_CVPR_2017_paper.html

 

CVPR 2017 Open Access Repository

Francois Chollet; Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017, pp. 1251-1258 We present an interpretation of Inception modules in convolutional neural networks as being an intermediate step in-between regular

openaccess.thecvf.com

 

우선, Xception을 리뷰하기 전 Inception에 대해 간단히 짚고 넘어가겠습니다. 

 

Inception 모듈로 2014년도에 가장 높은 성적을 거둔 GoogleLeNet 을 만들었습니다.

 

 

 

 

 

1. Inception Module

 

 

Inception Module

 

인셉션 모듈은 이전 단계의 활성화 지도에 다양한 필터 크기(Kernel_Size)로 합성곱 연산을 적용하는 방식입니다.

 

쉽게 표현하면, 강아지 사진에서 귀, 코, 눈 등의 특징을 다른 방향으로 보는 것입니다. 

 

다른 방향에서 보기 때문에, 같은 강아지 사진에서 다른 특성들을 추출할 수 있습니다.

 

인셉션은 적은 파라미터로 다양한 특징값을  추출하는데 의미가 있습니다.

 

class InceptionModule(nn.Module):
    def __init__(self, n_channels=10):
        super(InceptionModule, self).__init__()
        # Sequential : 연산을 차례로 수행

        self.conv2d_3k = nn.Conv2d(in_channels=n_channels,
                                   out_channels=n_channels,
                                   kernel_size=3,
                                   padding=1)

        self.conv2d_1k = nn.Conv2d(in_channels=n_channels,
                                   out_channels=n_channels,
                                   kernel_size=1)

        self.avgpool2d = nn.AvgPool2d(kernel_size=1)

    def forward(self, x):
        y1 = self.conv2d_1k(x)

        y2_1 = self.conv2d_1k(x)
        y2_2 = self.conv2d_3k(y2_1)

        y3_1 = self.avgpool2d(x)
        y3_2 = self.conv2d_3k(y3_1)

        y4_1 = self.conv2d_1k(x)
        y4_2 = self.conv2d_3k(y4_1)
        y4_3 = self.conv2d_3k(y4_2)

        out = torch.cat([y1, y2_2, y3_2, y4_3], dim=1)

        return out

 

 

2. 단순한 Inception Module

A Simplified Inception Module

 

저번 글에 나온 Depthwise Separable Convolution의 핵심 개념인 spartial correlation(3x3 convolution)cross channel correlation(1x1 convolution)이 등장합니다. 

 

여기 Standard Convolution과 차별 점은 서로가 매핑(mapping)되지 않고 독립적으로 수행하는 것입니다.

 

Figure1의 복잡함을 최대한 Simple하게 가는데 의미가 있습니다.

 

class SimplyInceptionModule(nn.Module):
    def __init__(self, n_channels=10):
        super(SimplyInceptionModule, self).__init__()
        # Sequential : 연산을 차례로 수행

        self.conv2d_3k = nn.Conv2d(in_channels=n_channels,
                                   out_channels=n_channels,
                                   kernel_size=3,
                                   padding=1)

        self.conv2d_1k = nn.Conv2d(in_channels=n_channels,
                                   out_channels=n_channels,
                                   kernel_size=1)

    def forward(self, x):
        y1_1 = self.conv2d_1k(x)
        y1_2 = self.conv2d_3k(y1_1)

        y2_1 = self.conv2d_1k(x)
        y2_2 = self.conv2d_3k(y2_1)

        y3_1 = self.conv2d_1k(x)
        y3_2 = self.conv2d_3k(y3_1)

        out = torch.cat([y1_2, y2_2, y3_2], dim=1)

        return out

 

 

3. 더 단순한 Inception module

A strictly equivalent reformulation of the simplified Inception module

 

Figure2에서 1x1 Convolution을 Input마다 독립적으로 수행했다면,

 

Figure3에서는 1x1 Convolution을 input 한 번만을 수행합니다. 

 

1x1 Convolution 수행한 output을 (그룹으로) 분리하여 3x3 Convolution을 수행합니다. 

 

Figure2를 변형하여 더 Simple하게!

 

SimplyInceptionModule3 = nn.Sequential(
    nn.Conv2d(in_channels=9,
              out_channels=9,
              kernel_size=1,
              bias=False),
              
    nn.ReLU(),

    nn.Conv2d(in_channels=9,
              out_channels=9,
              kernel_size=3,
              groups=3,
              bias=False),
    
    nn.ReLU()

)

 

 

 

 

이 논문에서 중요한 부분이라고 생각되는 부분입니다. 

 

 This observation naturally raises the question: 
 
 이 관찰은 당연히 문제를 제기합니다.
 
 what is the effect of the number of segments in the partition (and their size)?
 
 파티션의 세그먼트 수 (및 크기)는 어떤 영향을 미칩니까?
 

 

 

 

 

4. Extreme version of Inception module

Figure3에서 Output Channels를 최대로 그룹을 지어 분리하여 수행하면 어떨까?

 

An Extreme version of Inception module

 

위 논문의 질문의 가설로,  파티션의 세그먼트를 최대 단위로 수행한다면 어떻게 되는가?

 

ExtremeInception = nn.Sequential(
    nn.Conv2d(in_channels=9,
              out_channels=9,
              kernel_size=1,
              bias=False),
              
    nn.ReLU(),

    nn.Conv2d(in_channels=9,
              out_channels=9,
              kernel_size=3,
              groups=9,
              bias=False),
    
    nn.ReLU()

)

 

 

We remark that this extreme version of an Inception module is almost identical to a depthwise 
separable convolution, an operation that has been used in neural network design as early as 
2014 and has become more popular since its inclusion in the TensorFlow framework in 2016.


An extreme version of Inception module은 2014 년 초 신경망 설계에 사용되었으며 2016 년 TensorFlow 프레임 워크에 
포함 된 이후 더 널리 사용되는 Depthwise Separable Convolution과 거의 동일합니다.

 

depthwise separable convolution 와 비슷한 형태의 모듈이 생성됩니다.

 

depthwise separable convolution가 궁금하시면

 

https://coding-yoon.tistory.com/77

 

[딥러닝] Depthwise Separable Covolution with Pytorch( feat. Convolution parameters VS Depthwise Separable Covolution paramet

안녕하세요. Google Coral에서 학습된 모델을 통해 추론을 할 수 있는 Coral Board & USB Accelator 가 있습니다. 저는 Coral Board를 사용하지 않고, 라즈베리파이4에 USB Accelator를 연결하여 사용할 생각입니..

coding-yoon.tistory.com

 

Xception을 한 번에 작성할려고 했지만 생각보다 쓸 것이 많아 2편 정도로 연장될 것 같습니다. 

 

첫 논문 리뷰인데 부족한 부분이 많습니다. 피드백 주시면 감사하겠습니다.

 

 

728x90
반응형

+ Recent posts