코딩도상국

안녕하세요. 오늘은 Indoor Positioning에서 [cm]단위의 오차를 내는 UWB 관련 논문에 이야기하겠습니다. 

coding-yoon.tistory.com/136?category=910542

BLE는 기기간 수신신호세기(RSSI)를 이용해 Indoor Positioning을 하는 방면, UWB는 nanosecond(10e-9)의 길이를 갖는 매우 짧은 펄스를 이용하여 통신하는 방식입니다. 

시간 분해능이 매우 높아 최단 경로와 다중 경로간의 신호구별을 용이하여 수 cm이내의 정확도로 거리 측정이 가능하고 낮은 전력 밀도로 저전력 대용량 데이터 전송이 가능합니다. 

대표적으로 TWR(Two Way Ranging) 방식으로 Distance를 추정합니다. 

t_round A : 노드 A가 거리측적용 메세지를 송신한 순간부터 노드 B의 응답 메세지를 수신했을 때의 시간, 즉 거리 측정                 메세지의 왕복시간(Round Trip Time : RTT)

t_reply B : 노드 B의 응답시간 또는 처리 시간(Processing Time)

t_p : 거리 측정 메세지의 단방향 도달 시간

일반 TWR은 두 기기간의 하드웨어적 차이로 인해 시간 측정이 달라 TOA에 오차가 발생할 수 있어, SDS-TWR 등 많은 방식이 존재합니다.

< [UWB] IEEE 802.15.4a UWB 기반 실내 위치측정 시스템의 설계 및 구현 > 

기본적으로 UWR을 이용하여 거리를 구하는 방법을 알아보았으며, Non-Line of Sight 에 대해 알아보겠습니다. 

ieeexplore.ieee.org/document/9108193

논문의 아이디어는 UWB LOS/NLOS 분류를 딥러닝을 통해 성능을 향상시키는 것입니다. 

(Line of Sight, Non-Line of Sight)

실내 환경은 다양한 장애물(책상, 캐비넷, 책장 등)으로 가득차있으며, 이 장애물을 통해 UWB 신호는 반사될 수 있으며, 신호 수신은 직접 수신 된 신호에 비해 거리 정보에 더 긴 전송 시간을 가져오고 추가적인 Time-varying bias를 유발합니다. 

cf) UWB 신호의 오차는 대게 양의 값(+)을 가집니다. UWB 신호는 Nanosecond 단위로 시간측정 방식이기 때문에, 신호가 반사되면 지연 시간이 더해져 오차로 발생하기 때문입니다.

반사를 통해 오차를 일으킨 NLOS를 제거하면, 정확한 거리를 구할 수 있습니다. 

가장 직접적인 접근 방식은 UWB 신호 전파 경로 손실 모델 또는 CIR (Channel Impulse Response)을 기반으로 NLOS / LOS 신호 특성을 분석하는 것입니다.

위 논문은 Doctor Klemen Bregar providing the UWB NLOS/LOS open source data 를 이용

github.com/ewine-project/UWB-LOS-NLOS-Data-Set

이 포스팅은 두 편을 걸쳐 진행됩니다. ( 1편 : 오픈소스 데이터셋 전처리, 2편 : 논문 기반 네트워크를 통해 학습 )

Doctor Klemen Bregar providing the UWB NLOS/LOS open source data를 딥러닝을 위해 전처리 과정이 필요합니다. 

오픈소스는 csv, 데이터를 불러오는 모듈로 구성되어 있습니다. 

4년 전 데이터이므로 pandas 버전 오류 해결을 위해 uwb_dataset.py를 약간 변경했습니다.

uwb_dataset.py

"""
Created on Feb 6, 2017
@author: Klemen Bregar 
"""

import os
import pandas as pd
from numpy import vstack


def import_from_files():
    """
        Read .csv files and store data into an array
        format: |LOS|NLOS|data...|
    """
    rootdir = '../dataset/'
    output_arr = []
    first = 1
    for dirpath, dirnames, filenames in os.walk(rootdir):
        for file in filenames:
            filename = os.path.join(dirpath, file)
            print(filename)
            output_data = [] 
            # read data from file
            df = pd.read_csv(filename, sep=',', header=0)
            # ------------------------ update Mar 3, 2021 ----------------------------- #
            columns_name = df.columns.values
            # ------------------------ update Mar 3, 2021 ----------------------------- #
            

            # ------------------------ update Mar 3, 2021 ----------------------------- #
            # input_data = df.as_matrix()
            # df.as_matrix() was depriciated after the version 0.23.0 use df.values()
            input_data = df.values
            
            # ------------------------ update Mar 3, 2021 ----------------------------- #
            
            # append to array
            if first > 0:
                first = 0
                output_arr = input_data
            else:
                output_arr = vstack((output_arr, input_data))
    
    return columns_name, output_arr

if __name__ == '__main__':

    # import raw data from folder with dataset
    print("Importing dataset to numpy array")
    print("-------------------------------")
    data = import_from_files()
    print("-------------------------------")
    # print dimensions and data
    print("Number of samples in dataset: %d" % len(data))
    print("Length of one sample: %d" % len(data[0]))
    print("-------------------------------")
    print("Dataset:")
    print(data)

1. Load UWB data

import numpy as np
import pandas as pd
import uwb_dataset

# import raw data
data = uwb_dataset.import_from_files()

# divide CIR by RX preable count (get CIR of single preamble pulse)
# item[2] represents number of acquired preamble symbols
for item in data:
	item[15:] = item[15:]/float(item[2])

print("\nColumns :", columns.shape, sep=" ")
print("Data :", data.shape, sep=" ")
print(type(data))

2. Create UWB(CIR) Pandas Dataframe

cir_n = len(columns[15:])

print("Columns :", columns, sep=" ")
print("Channel Inpulse Response Count :", cir_n, sep=" ")

df_uwb = pd.DataFrame(data=data, columns=columns)
print("Channel 2 count :", df_uwb.query("CH == 2")['CH'].count())
print("Null/NaN Data Count : ", df_uwb.isna().sum().sum())
df_uwb.head(3)

# LOS/NLOS Count
los_count = df_uwb.query("NLOS == 0")["NLOS"].count()
nlos_count = df_uwb.query("NLOS == 1")["NLOS"].count()

print("Line of Sight Count :", los_count)
print("Non Line of Sight Count :", nlos_count)

# Columns CIR Extract
df_uwb_data = df_uwb[["CIR"+str(i) for i in range(cir_n)]]
print("UWB DataFrame X for Trainndarray shape : ",df_uwb_data.values.shape)
df_uwb_data.head(5)

Columns : Sampling 1016 CIR

LOS : 21000, NLOS : 21000  Pandas Dataframe 

다음 글은 생선된 위 데이터 프레임을 이용해 논문에 제시된 CNN+LSTM 모델을 Pytorch로 구현하겠습니다.

coding-yoon.tistory.com/139

안녕하세요. 오늘은 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

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를 짚고 넘어가자면, 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

4. Conclusions

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

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

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 논문 리뷰를 마치도록 하겠습니다. 피드백주시면 감사하겠습니다.

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

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

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

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

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

1. 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

저번 글에 나온 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

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를 최대로 그룹을 지어 분리하여 수행하면 어떨까?

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

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

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

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