코딩도상국

그림 참고 1:

Early Warning Model of Wind Turbine Front Bearing Based on Conv1D and LSTM | IEEE Conference Publication | IEEE Xplore

그림 참고 2:

Understanding 1D and 3D Convolution Neural Network | Keras | by Shiva Verma | Towards Data Science

1. 데이터셋 가정

Batch size : 100000

Sequence : 10

Feature : 3 (x-axis, y-axis, z-axis)

Dataset shape : (100000, 10, 3) = (Batch size, Sequence, Feature) = (B, S, F)

2. 모델 구성

1. Conv1D

  CNN은 convolution layer, pooling layer, fully connected layer로 주로 구성된다. 그 중 convolution layer와 pooling layer는 두 개의 특수 신경망 레이어로 주로 유효 특징 추출을 담당한다. 원본 데이터에서 벡터를 추출하고 원본 기능의 공간적 정보를 마이닝할 수 있다. 가속도계와 같은 1차원 데이터를 1차원 컨볼루션 신경망(Conv1D)을 사용하여 서로 다른 변수를 결합하고 변수 간의 공간적 상관 관계를 추출한다.

  Conv1D는 그림 2와 같이 한 차원에 대해 커널 슬라이딩을 통해 공간적 상관 관계를 추출한다.

2. LSTM

  LSTM은 시계열 데이터를 처리하기 위한 고전적인 딥 러닝 네트워크이다. 순환 신경망이 긴 시계열을 어느 정도 처리할 때 기울기 소실(Vanishing gradient) 문제를 해결하는 순환 신경망의 변형입니다. 장기 및 단기 기억 네트워크의 셀 구조는 그림 3과 같이 망각 게이트, 입력 게이트 및 출력 게이트가 있다.

  3. Conv1D + LSTM 

  Conv1D + LSTM 모델은 그림 1과 같이 Conv1D 기반의 특징 융합 레이어, LSTM 기반 시계열 예측 레이어, output layer로 구성된다. Input layer에는 그림 0과 같은 시공간적 특성행렬이 입력된다. 각 변수는 CNN에 의해 ​​가중치가 부여되고 변수 간의 정보가 결합된다. 과적합(Overfitting)을 피하기 위해 dropout layer가 네트워크에 추가됩니다. 모델 파라미터는 그림 4와 같이 구성한다.

모델을 구성하게 되면 아래의 코드와 같이 구현할 수 있다. 

import torch.nn as nn


class Conv1d_LSTM(nn.Module):
    def __init__(self, in_channel=3, out_channel=1):
        super(Conv1d_LSTM, self).__init__()
        self.conv1d_1 = nn.Conv1d(in_channels=in_channel,
                                out_channels=16,
                                kernel_size=3,
                                stride=1,
                                padding=1)
        self.conv1d_2 = nn.Conv1d(in_channels=16,
                                out_channels=32,
                                kernel_size=3,
                                stride=1,
                                padding=1)
        
        self.lstm = nn.LSTM(input_size=32,
                            hidden_size=50,
                            num_layers=1,
                            bias=True,
                            bidirectional=False,
                            batch_first=True)
        
        self.dropout = nn.Dropout(0.5)

        self.dense1 = nn.Linear(50, 32)
        self.dense2 = nn.Linear(32, out_channel)

    def forward(self, x):
	# Raw x shape : (B, S, F) => (B, 10, 3)
        
        # Shape : (B, F, S) => (B, 3, 10)
        x = x.transpose(1, 2)
        # Shape : (B, F, S) == (B, C, S) // C = channel => (B, 16, 10)
        x = self.conv1d_1(x)
        # Shape : (B, C, S) => (B, 32, 10)
        x = self.conv1d_2(x)
        # Shape : (B, S, C) == (B, S, F) => (B, 10, 32)
        x = x.transpose(1, 2)
        
        self.lstm.flatten_parameters()
        # Shape : (B, S, H) // H = hidden_size => (B, 10, 50)
        _, (hidden, _) = self.lstm(x)
        # Shape : (B, H) // -1 means the last sequence => (B, 50)
        x = hidden[-1]
        
        # Shape : (B, H) => (B, 50)
        x = self.dropout(x)
        
        # Shape : (B, 32)
        x = self.fc_layer1(x)
        # Shape : (B, O) // O = output => (B, 1)
        x = self.fc_layer2(x)

        return x

안녕하세요.

오늘부터 LoRa 관련하여 포스팅을 시작하겠습니다.

TTN(The Things Network)에서 제공하는 자료를 기반으로 LoRa 기초를 다지기 좋습니다.

https://www.thethingsnetwork.org/docs/lorawan/

사물인터넷의 발전으로 초소형 통신장치 수요가 증가함에 따라, 기존에 IoT를 위하여 대표적으로 활용되던 WiFi, BLE, Zigbee와 같은 근거리 네트워크가 발전되었습니다.

하지만 장거리를 필요로 하는 서비스에는 부적합하여 저전력＊장거리 통신 기술인 LPWAN (Low Power Wide Area Network)에 대한 많은 연구가 진행 중입니다. 

LPWAN은 아래와 같은 종류들이 있습니다.

면허 대역 : NB-IoT (LG)

비면허 대역 : LoRa (SKT), Sigfox

LPWA기반 광역 IoT기술 및 표준화 (Wide Range IoT Technology and Standardization based on LPWA)
https://ettrends.etri.re.kr/ettrends/158/0905002120/

저는 LPWAN 중에서도 LoRa에 대해 포스팅합니다.

( 한국에서는 대표적으로 LoRa를 다루는 곳은 SKT 텔레콤과 한전 KDN이 있습니다. )

LoRa : 장거리 저전력 무선 플랫폼으로서 (한국에서) 920MHz 대역의 주파수를 사용하는 무선통신 기술.

LoRaWAN : LoRa 무선 통신 기술을 이용한 광역 네트워크 

LoRa의 특징을 말하기 앞서 이 글에 가장 중요하다고 생각되는 부분은 LoRa와 LoRaWAN의 차이입니다.

LoRa는 물리(Physical) 계층에 속하며 Semtech이 보유한 무선 통신 기술입니다. 

LoRaWAN은 링크(Mac) 계층에 속하며 LoRa Alliance가 이를 규정하고 있습니다. 

그래서 LoRaWAN을 구현할 때는 Semtech 문서와 LoRa Alliance 문서를 참고하여야 합니다.

https://lora-alliance.org/lorawan-for-developers/

LoRa의 대표 특징은

1. Low Power (저전력)
2. Long Range (장거리)
3. License free spectrum (주파수 스펙트럼 무료 라이센스)
4. 변조 방식 : CSS (Chirp Spread Spectrum)

LoRaWAN 대표 특징은

1. 변조 방식 : CSS, FSK
2. 접속 절차 : OTAA(Over-The-Air-Activation), ABP(Activation By Personalization)
3. Class : Class A, Class B, Class C
4. 단일 홉 (one-hop) Star topology
5. 네트워크 보안 : AES 128 암호화
6. 세션 키 : 네트워크 세션 키, 어플리케이션 세션 키

장점은

1. 네트워크가 구축되어 있지 않은 야외 나 네트워크 구축이 힘든 실내 환경에 활용 가능
2. 낮은 사용료와 저렴한 초기 구축비
3. 단순한 접속 절차 (OTAA, ABP)로 대량의 단말기(End Device) 간단하게 수용 가능
4. End Device가 복수의 기지국에 접속 가능하여 최적의 경로로 네트워크에서 단말기로 데이터 전송이 가능
5. Sensitivity 특성이 좋아서 신호 간섭에 강하고 최적의 주파수 활용도를 제공
6. LoRa는 기기간 동기를 맞출 필요가 없고, 채널에 대한 모니터링이 필요 X

위와 같이 볼 수 있습니다.

간단히 이 정도로 소개하며, 이제부터 하나하나 자세히 포스팅 해나가도록 하겠습니다.

안녕하세요. 

Plain Network(단순히 Layer을 깊게 쌓음)에서 발생하는 Vanishing Gradient(기울기 소실), Overfitting(과적합) 등의 문제를 해결하기 위해 ReLU, Batch Nomalization 등 많은 기법이 있습니다. 

ILSVRC 대회에서 2015년, 처음으로 Human Recognition보다 높은 성능을 보인 것이 ResNet입니다.

그 위용은 무지막지한 논문 인용 수로 확인할 수 있습니다. 

그렇기 때문에 ResNet은 딥러닝 이미지 분야에서 바이블로 통하고 있습니다. 

Plain Network는 단순히 Convolution 연산을 단순히 쌓는다면, ResNet은 Block단위로 Parameter을 전달하기 전에 이전의 값을 더하는 방식입니다. 

F(x) : weight layer => relu => weight layer 

x : identity

weight layer들을 통과한 F(x)와 weight layer들을 통과하지 않은 x의 합을 논문에서는 Residual Mapping 이라 하고, 그림의 구조를 Residual Block이라 하고, Residual Block이 쌓이면 Residual  Network(ResNet)이라고 합니다.

Residual Mapping은 간단하지만, Overfitting, Vanishing Gradient 문제가 해결되어 성능이 향상됐습니다.

그리고 다양한 네트워크 구조에서 사용되며, 2017년 ILSVRC을 우승한 SeNet에서 사용됩니다. ( 이 글을 쓴 이유이기도 합니다. ) 

class Residual_Block(nn.Module):
    def __init__(self, in_dim, mid_dim, out_dim):
        super(Residual_Block,self).__init__()
        # Residual Block
        self.residual_block = nn.Sequential(
                nn.Conv2d(in_dim, mid_dim, kernel_size=3, padding=1),
                nn.ReLU,
                nn.Conv2d(mid_dim, out_dim, kernel_size=3, padding=1),
            )            
        self.relu = nn.ReLU()
                  
    def forward(self, x):
       out = self. residual_block(x)  # F(x)
        out = out + x  # F(x) + x
        out = self.relu(out)
        return out
    

그리고 Residual Block 소개 후 BottleNeck이 나옵니다. 아래 글을 참고하시면 좋을 것 같습니다. 

coding-yoon.tistory.com/116?category=825914

ResNet 원문

arxiv.org/abs/1512.03385

안녕하세요. 오늘은 Deep Learning 분야에서 CNN의 BottleNeck구조에 대해 알아보겠습니다. 

대표적으로 ResNet에서 BottleNeck을 사용했습니다. 

ResNet에서 왼쪽은 BottleNeck 구조를 사용하지 않았고, 오른쪽은 BottleNeck 구조를 사용했습니다.

BottleNeck을 설명하기 전, Convolution의 Parameters을 계산할 줄 알아야 합니다. 이 부분은 다른 글에서 자세히 설명하겠습니다.

Convolution Parameters = Kernel Size x Kernel Size x Input Channel x Output Channel

BottleNeck의 핵심은 1x1 Convolution입니다. ( Pointwise Convolution 이라고도 합니다. 이는 Depthwise Separable Convolution에서도 똑같은 원리로 이용되기 때문에 잘 알아두면 좋습니다.)

1x1 Convolution의 Parameters는 1 x 1 x Input Channel x Output Channel입니다.

대게 1x1 Convolution은 연산량이 작기 때문에 Feature Map(Output Channel)을 줄이거나 키울 때 사용됩니다.

BottleNeck 구조

1. Input Channel = 256인 320x320  Input Image가 있다고 가정합니다. 

2. Channel Compression ( 채널 압축 )

Input Channel 256 -> Output Channel 64

256을 64로 채널을 강제로 축소한 이유는 오로지 연산량을 줄이기 위함입니다. 

1x1 Convolution에는 Spatial(공간적인) 특징을 가지고 있지 않습니다. Convolution 연산이 공간적인 특징을 추출하기 위해선 Kernel이 최소 2 이상 되어야 합니다. 

3. 특징 추출

Input Channel 64 -> Output Channel 64 

3x3 Convolution은 특성을 추출하는 역할을 합니다.

3x3 Convolution 연산은 = 3 x 3 x Input Channel x Output Channel 입니다. ( 3 x 3 x 64 x 64 )

3x3 Convolution은 1x1 Convolution 보다 9배 연산량이 많기 때문에, 1x1 Convolution에서 채널을 줄인 후에 

3x3 Convolution에서 특성을 추출합니다. 

4. Channel Increase( 채널 증가 )

Input Channel 64 -> Output Channel 256

CNN은 Feature Map의 특성이 많으면 많을수록 학습이 잘 되기 때문에, 1x1 Convolution으로 강제적으로 채널을 증가시켜줍니다. 

BottleNeck의 구조는 1x1 Convolution으로 장난을 치면서 연산량을 최소화하는 것입니다. 

하지만 강제로 채널을 줄이고 늘리는 것은 정보 손실을 일으킵니다. 

정보 손실은 모델의 정확성을 떨어뜨립니다. 

연산량과 정보손실은 서로 tradeoff 관계이기 때문에 서로의 합의점을 찾는 것이 중요합니다. 

ResNet이 제시한 두 구조를 Pytorch로 구현해 Parameter를 확인하겠습니다. 

Standard는 Channel 수가 적을지라도, 3x3 Convolution을 두 번 통과했고, 

BottleNeck은 1x1, 3x3, 1x1 순으로 Convolution을 통과하고, Channel 수는 4배 정도 많지만, Parameter가 세 배 정도 적습니다. 

그리고 형성된 것이 도로의 병목 현상과 비슷하다 하여 BottleNeck 구조라고 불립니다.

cf) Pytorch Code

# standard
class Standard(nn.Module):
    def __init__(self, in_dim=256, mid_dim=64, out_dim=64):
        super(BuildingBlock, self).__init__()
        self.building_block = nn.Sequential(
            nn.Conv2d(in_channels=in_dim, out_channels=mid_dim, kernel_size=3, padding=1, bias=False),
            nn.ReLU(),
            nn.Conv2d(in_channels=mid_dim, out_channels=out_dim, kernel_size=3, padding=1, bias=False),
        )
        self.relu = nn.ReLU()

    def forward(self, x):
        fx = self.building_block(x)  # F(x)
        out = fx + x  # F(x) + x
        out = self.relu(out)
        return out

# BottleNeck
class BottleNeck(nn.Module):
    def __init__(self, in_dim=256, mid_dim=64, out_dim=256):
        super(BottleNeck, self).__init__()
        self.bottleneck = nn.Sequential(
            nn.Conv2d(in_channels=in_dim, out_channels=mid_dim, kernel_size=1, bias=False),
            nn.ReLU(),
            nn.Conv2d(in_channels=mid_dim, out_channels=mid_dim, kernel_size=3, padding=1, bias=False),
            nn.ReLU(),
            nn.Conv2d(in_channels=mid_dim, out_channels=in_dim, kernel_size=1, bias=False),
        )

        self.relu = nn.ReLU()

    def forward(self, x):
        fx = self.bottleneck(x)  # F(x)
        out = fx + x  # F(x) + x
        out = self.relu(out)
        return out