DEEP.I INC. | 주식회사 딥아이 연구소

[Jetson] Nvidia 젯슨 Nano or NX SD 카드 복사하기 (Clone SD Card)

주식회사 딥아이 — Mon, 11 Oct 2021 11:46:02 +0900

Jetson Series

젯슨 나노는 NVIDIA에서 제작한 딥러닝용 보드로 GPU 연산이 가능한 프로세서를 탑재하여 CUDA를 활용한 이미지 프로세싱과 딥러닝 연산이 가능합니다. 가격 또한 저렴?하여 다양한 산업용 시스템 구현에 활용 가능성이 높습니다.

이번 포스팅은 백업이나 여러개의 잿슨 나노를 동일하게 구동하게 될 경우 필요한 SD 카드 복사 ( HARD COPY) 가이드입니다. 다양한 방법과 시도가 있었습니다. 하단의 링크는 영상과 함께 설명되어 쉽게 복사가 됩니다. 저 역시 이 방법을 주로 사용하고 있습니다.

https://www.jetsonhacks.com/2020/08/08/clone-sd-card-jetson-nano-and-xavier-nx/

Clone SD Card - Jetson Nano and Xavier NX - JetsonHacks

If you have a Jetson Nano or Xavier NX Developer Kit, you can make a clone image of the SD card using the dd utility. Nice to have a backup!

www.jetsonhacks.com

준비 사항

Jetson os가 정상적으로 설치된 SD 카드
복사를 위한 동일 크기의 SD 카드
복사가 진행될 호스트 컴퓨터 (우분투 기준)

64GB SD 카드를 사용하고 있다면 동일한 메모리를 가지는 SD카드가 필요합니다. 말 그대로 SD 카드 전체를 복사하는 과정이기 때문에 사용하고 있는 용량이 없더라도 기준이 되는 SD카드와 동일해야 합니다.

또한, 리눅스 PC가 필요합니다. 아직 윈도우에서 가능 여부는 확인되지 않았습니다.

SD 카드 원본 백업

잿슨 OS가 설치된 SD카드를 호스트 리눅스 컴퓨터에 연결한 다음 아래 명령어를 통해 연결된 포트를 확인합니다.

sudo parted -l

deep@deepi:~$ sudo parted -l
[sudo] password for deep: 
Model: Mass Storage Device (scsi)
Disk /dev/sda: 63.9GB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Disk Flags: 

Number  Start   End     Size    File system  Name     Flags
 2      1049kB  1180kB  131kB                TBC
 3      2097kB  2556kB  459kB                RP1
 4      3146kB  3736kB  590kB                EBT
 5      4194kB  4260kB  65.5kB               WB0
 6      5243kB  5439kB  197kB                BPF
 7      6291kB  6685kB  393kB                BPF-DTB
 8      7340kB  7406kB  65.5kB               FX
 9      8389kB  8847kB  459kB                TOS
10      9437kB  9896kB  459kB                DTB
11      10.5MB  11.3MB  786kB                LNX
12      11.5MB  11.6MB  65.5kB               EKS
13      12.6MB  12.8MB  197kB                BMP
14      13.6MB  13.8MB  131kB                RP4
 1      14.7MB  63.9GB  63.8GB  ext4         APP

여러 저장장치가 연결되어있다면, 모든 정보가 나열됩니다. 그중에서 연결한 SD 카드 정보만 확인하면 됩니다. 사용된 SD카드의 메모리는 64GB 이며, 현재 /dev/sda 에 마운트 된 것을 확인할 수 있습니다.

마운트 위치를 확인하였다면 복사를 시작합니다.

# {}는 마운트 위치입니다.
sudo umount /dev/sd{}

$ sudo dd if=/dev/{} conv=sync,noerror bs=64K | gzip -c > ~/backup_image.img.gz

연결된 환경에 맞게 {}를 sda나 sdb 등으로 채워준 다음 실행하면 해당 경로에 SD카드가 복사됩니다. 전체 메모리가 크기 때문에 고속 SD 카드와 USB 3.0 이상의 속도를 지원하는 리더기 사용을 권장합니다. 고속 SD카드의 경우 10 ~ 20분 내로 복사가 완료되지만 저렴한 SD 카드의 경우, 1시간 이상 소요되기도 합니다.

SD 카드 복사

복사가 완료되었다면 SD카드를 새로 복사할 SD카드로 변경합니다. 이후, 동일하게 sudo parted -l 명령어로 마운트 위치를 찾아줍니다. 복사는 루트 권한으로 해야 하기 때문에 아래와 같이 진행합니다.

$ sudo su
$ gunzip -c ~/backup_image.img.gz | dd of=/dev/{} bs=64K

복사 과정도 동일하게 SD 카드 속도에 따라 시간이 20 ~ 1시간 이상 걸리기도 합니다. 한 장 복사에 총 2시간 이상이 소요됩니다... 따라서 웬만해서는 고속 리더기와 SD 카드를 사용하시는 게 좋습니다.

Your Best AI Partner DEEP.I
AI 바우처 공급 기업
객체 추적 및 행동 분석 솔루션 | 제조 생산품 품질 검사 솔루션 | AI 엣지 컴퓨팅 시스템 개발
인공지능 프로젝트 개발 외주 및 상담
E-mail: contact@deep-i.ai
Site: www.deep-i.ai

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

딥아이는 AI 기술의 정상화라는 목표를 갖고, 최첨단 딥러닝 기술 기반의 기업 솔루션을 제공하고 있으며, 이를 통해 고도의 AI 기반 객체 탐지, 분석, 추적 기능을 통합하여 다양한 산업 분야에

deep-i.ai

딥러닝 머신러닝을 이용한 지능형 시스템 개발 문의

주식회사 딥아이 — Fri, 9 Apr 2021 00:23:51 +0900

안녕하세요, 오프라인 공간의 지능화를 꿈꾸는 DEEP.I 입니다.

딥아이는 예비창업패키지 4차산업 인공지능 우수기업으로 선정된 이후, 충청남도청과 순천향대학교를 비롯한 다양한 기업, 개인과 컴퓨터 비전 기반 지능형 솔루션 개발 프로젝트를 진행한 경험이 있습니다.

또한 딥러닝 기술 관련 연구적 성과로 4편 이상의 SCIE 급 논문, 7건 이상의 특허 출원 및 등록 되었습니다.

딥러닝 기반 지능형 솔루션 개발 프로젝트가 필요한 모든 분들께 최선을 다할것이며, 서비스는 활용되는 데이터와 모델 구현 난이도에 따라 가격이 조정될 수 있습니다.

기한 역시 절대적이지 않습니다. 하지만, 서두르지 않고, 최선을 다해 최고의 솔루션을 제공해드리겠습니다. 문제 정의가 어렵고, 정확한 기술적 개념이 명확하지 않으셔도, 문의 주시면 성심성의껏, 이해하기 쉽고 가이드라인을 잡을 수 있도록 상담해드리도록 하겠습니다. 감사합니다.

제공 서비스 기술

* 딥러닝 기반 이미지 분류 [MLP, SVM, CNN 등]

* 딥러닝 기반 영상 객체 탐지 [YOLO, FASTER-RCNN 등]

* 딥러닝 기반 행동 인식 [SLOWFAST, LSTM, RNN 등]

* 딥러닝 기반 다중 센서 융합 [영상 카메라, 열화상 카메라, 라이다 센서 등]

* 딥러닝 기반 얼굴 인식 및 식별 [VGGFACE, DEEPFACE 등]

* Jetson 시리즈 기반 엣지 컴퓨팅 시스템 [Jetson Nano, TX2, Xavier]

제공 서비스 프로그래밍 언어

* Python - [tensorflow, pytorch, pyqt]

* Matlab - [Computer Vision]

안전거래를 이용해 크몽에서 진행하시시고자 하실 경우 크몽을 통해 상담 톡 주시기 바랍니다.

크몽 서비스 홈페이지 : kmong.com/gig/302516

딥러닝 머신러닝을 이용한 지능형 시스템 솔루션 개발해 드립니다. | 300000원부터 시작 가능한 총

0개 총 작업 개수 완료한 총 평점 0점인 딥아이랩의 IT·프로그래밍, 데이터분석·리포트, 인공지능·머신러닝 서비스를 0개의 리뷰와 함께 확인해 보세요. IT·프로그래밍, 데이터분석·리포트, 인

kmong.com

외주 용역 계약서 및 기업 간 거래를 진행하시고자 하면 메일 또는 당사 홈페이지에서 문의 주시기 바랍니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] OpenCV 웹캠 연결 문제 cv2.VideoCapture 해결 방법 #1

주식회사 딥아이 — Mon, 29 Mar 2021 17:47:23 +0900

Concept

윈도우 기본 카메라 앱에서는 출력되지만, opencv에서 특정 웹캠 연결 문제가 발생하여 영상이 출력되지 않는 경우가 가끔 발생합니다. 다양한 이유가 있지만, 동영상 프레임을 불러오는 과정을 결정짓는 apiPreference 문제로 발생하기도 합니다.

일반적으로 opencv가 알아서 최적값을 찾아주지만 영상 출력이 되지 않는다면 한 번 시도해보길 바랍니다.

VideoCaptureAPIs 열거형 상수	설명
CAP_ANY	자동 선택
CAP_V4L, CAP_V4L2	V4L/V4L2(리눅스)
CAP_FIREWIRE, CAP_FIREWARE, CAP_IEEE1394	IEEE 1394 드라이버
CAP_DSHOW	다이렉트쇼(DirectShow)
CAP_PVAPI	PvAPI, Prosilica GigE SDK
CAP_OPENNI	OpenNI
CAP_MSMF	마이크로소프트 미디어 파운데이션 (Microsoft Media Foundation)
CAP_GSTREAMER	GStreamer
CAP_FFMPEG	FFMPEG 라이브러리
CAPIMAGES	OpenCV에서 지원하는 일련의 영상 파일 (예) img%02d.jpg
CAP_OPENCV_MJPEG	OpenCV에 내장된 MotionJPEG 코덱

import cv2

# 일반적으로 웹캠 불러오기
cam = cv2.VideoCapture(0)
ret, frame = cam.read()

# 기존 방식으로 연결이 안될 경우
# 여기서 숫자 0은 웹캠의 채널 인덱스

cam = cv2.VideoCapture(cv2.CAP_DSHOW+0)
ret, frame = cam.read()

cv2.CAP_DSHOW 이외에 여러 API 인자들이 있습니다. 연결이 안된다면 한 번쯤 시도해볼만 합니다.

Reference

thebook.io/006939/ch04/01/01-03/

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] Pyinstaller 오류 : A RecursionError (maximum recursion depth exceeded) occurred.For working around please follow these instructions 해결하기

주식회사 딥아이 — Wed, 24 Mar 2021 14:20:25 +0900

Concept

Pyinstaller는 파이썬 기반 실행 파일을 만드는 강력한 툴입니다. 윈도우나 맥 환경에 맞추어 자동으로 라이브러리와 필요 모듈을 내장하기 때문에 쉽게 배포판을 만들수 있죠.

하지만, 파이썬 자체 인터프리터의 용량과 기타 압축 한계로 인해 C 기반 프로그램보다 용량이 상당히 커진다는 단점이 있기는 합니다. 이를 위해 사용하는 오픈 라이브러리를 최소화하여 프로그래밍 하게됩니다.

프로젝트가 커지면 정말 많은 라이브러리를 Import하게 되는데, 이때 오류가 발생하곤 합니다.

파이썬을 실행파일로 만드는 과정에서 기준치 이상의 메모리 연산량을 요구하기 때문에 발생하는 오류입니다. 이를 해결하기 위해서는 오류와 함께 코드가 실행된 폴더에 생성되는 .spec 파일을 수정해야 합니다.

# -*- mode: python ; coding: utf-8 -*-

## 추가 코드
import sys
sys.setrecursionlimit(5000)
## 추가 코드

block_cipher = None


a = Analysis(['run_mvp.py'],
             pathex=['I:\\1ST_MEETING\\CODE\\DEEP_EYE_GPU\\MVP_2'],
             binaries=[],
             datas=[],
             hiddenimports=[],
             hookspath=[],
             runtime_hooks=[],
             excludes=[],
             win_no_prefer_redirects=False,
             win_private_assemblies=False,
             cipher=block_cipher,
             noarchive=False)
pyz = PYZ(a.pure, a.zipped_data,
             cipher=block_cipher)

txt 파일로 실행 한 뒤, 상단에 2줄을 추가해서 제한량을 늘려주어야 합니다. 기존 제한은 1000이라고 합니다. 저장한 다음 .spec 파일을 통해 다시 pyinstaller를 실행합니다.

pyinstaller 실행코드이름.spec

다소 시간이 걸리지만, 정상적으로 exe파일이 생성됩니다.

Reference

github.com/pyinstaller/pyinstaller/issues/5388

RecursionError · Issue #5388 · pyinstaller/pyinstaller

I'm getting back an error when I use Pyinstaller to obtain an executable file from a .py file. ============================================================= A RecursionError (maximum recursion ...

github.com

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Tensorflow] 학습을 위한 대용량 훈련 데이터 처리 Data Generator 클래스 만들기

주식회사 딥아이 — Wed, 17 Mar 2021 11:08:45 +0900

Concept

신경망 모델을 학습하기 위해 입력 데이터를 정리하고 전 처리하는 일은 중요하지만 언제나 귀찮은 일입니다. 특히, 이미지 데이터를 학습하기 위해 텐서 플로우에서 ImageGenerator를 설정하는 것은 소규모 데이터에서는 정리가 쉽지만, 대용량 대규모 데이터를 규격에 맞게 정리하는것은 쉽지 않죠.

이번 포스팅에서는 ImageGenerator.flow_ 함수를 직접 class로 만들어 커스터마이징이 쉽고 저장이 용이한 학습 데이터 구축 방법을 구현해보도록 하겠습니다.

SourceCode

keras.io/api/preprocessing/image/

Keras documentation: Image data preprocessing

Image data preprocessing image_dataset_from_directory function tf.keras.preprocessing.image_dataset_from_directory( directory, labels="inferred", label_mode="int", class_names=None, color_mode="rgb", batch_size=32, image_size=(256, 256), shuffle=True, seed

keras.io

1. Keras - ImageDataGenerator.flow_from_dataframe()

MNIST나 CIFAR과 같이 저용량 데이터는 구지 이미지 형식으로 저장할 필요 없이 csv, mat, pkl 파일로 묶어두고 그때그때 사용하면 편하지만, 이미지 크기가 100x100 이상만 넘어도 수만 장의 이미지를 메모리에 담는 것은 쉽지 않습니다. Dataframe으로 불러온 데이터를 데이터화하는 것은 대용량 데이터셋에 적합하지 않습니다.

2. Keras - ImageDataGenerator.flow_from_directory()

데이터를 메모리에 불러오기 전, 데이터가 있는 폴더의 주소로 이미지의 클래스를 구분하여 정렬해줍니다. 하지만, 지정된 폴더 이내 sub 폴더 형식으로 데이터가 분류되어 있어야 합니다. 한 번 정리하면 편하지만, 그때 그때 수십만 장의 이미지를 일일이 분류하기는 쉽지 않습니다.

3. Keras - Sequence 를 이용한 Generator 클래스 생성

예제로 설명되는 Generator는 다음 전처리 특성을 가지게 구현하였습니다.

Batch 사이즈 지정
입력 이미지 리사이징
입력 이미지 정규화
데이터와 라벨 일대일 대응

from keras.utils import to_categorical, Sequence

class DataGenerator(Sequence):
    def __init__(self, path, list_IDs, labels, 
    batch_size, img_size, img_channel, num_classes):
     
        # 데이터셋 경로
        self.path = path
        # 데이터 이미지 개별 주소 [ DataFrame 형식 (image 주소, image 클래스) ]
        self.list_IDs = list_IDs
        # 데이터 라벨 리스트 [ DataFrame 형식 (image 주소, image 클래스) ]
        self.labels = labels
        # 학습 Batch 사이즈
        self.batch_size = batch_size
        # 이미지 리사이징 사이즈
        self.img_size = img_size
        # 이미지 채널 [RGB or Gray]
        self.img_channel = img_channel
        # 데이터 라벨의 클래스 수
        self.num_classes = num_classes
        # 전체 데이터 수
        self.indexes = np.arange(len(self.list_IDs))
   
    def __len__(self):
        len_ = int(len(self.list_IDs)/self.batch_size)
        if len_*self.batch_size < len(self.list_IDs):
            len_ += 1
        return len_
    
    def __getitem__(self, index):
        indexes = self.indexes[index*self.batch_size:(index+1)*self.batch_size]
        list_IDs_temp = [self.list_IDs[k] for k in indexes]
        X, y = self.__data_generation(list_IDs_temp)
        return X, y
            
    def __data_generation(self, list_IDs_temp):
        X = np.zeros((self.batch_size, self.img_size, self.img_size, self.img_channel))
        y = np.zeros((self.batch_size, self.num_classes), dtype=int)
        for i, ID in enumerate(list_IDs_temp):
            img = cv2.imread(self.path+ID)
            img = cv2.resize(img, (self.img_size, self.img_size))
            X[i, ] = img/255
            y[i, ] = to_categorical(self.labels[i], num_classes=self.num_classes)
        return X, y

클래스 생성 뒤, __init__ 를 통해 입력 파라미터를 초기화해줍니다. 입력되는 값은 총 7개입니다. __data_generation 함수에서 데이터를 전 처리한 뒤, __getitem 함수에서 이를 배치 형식으로 정렬하여 출력해줍니다. 기존 flow_from_directory()와 동일하지만, 서브 폴더가 필요하지 않고 라벨과 클래스를 저장된 데이터프레임 파일에 맞게 자동으로 할당해주는 장점이 있습니다.

Application

train.csv

0.58MB

import pandas as pd

# 이미지 주소 및 클래스 라벨 파일 불러오기
train_labels = pd.read_csv('train.csv')

# 라벨 정보 전처리
# 전체 클래스 수
clss_num = len(train_labels['labels'].unique())
# 클래스 -> 숫자로 변환 (카테고리 형식의 클래스를 원 핫 인코딩)
labels_dict = dict(zip(train_labels['labels'].unique(), range(clss_num)))
train_labels = train_labels.replace({"labels": labels_dict})

tartget_size = 150
img_ch = 3
num_class = 12
batch_size = 32

train_generator = DataGenerator('train_images/', train_labels['image'],
                                train_labels['labels'],
                                batch_size, tartget_size,
                                img_ch, num_class)
 
# 학습
# history = model.fit_generator(train_generator, epochs=1)

현재 가공된 데이터셋의 형식에 따라 이 방법이 편할수도 있지만, 불편할 수도 있습니다. 데이터셋의 이름이 클래스 별로 구분되어있거나 하위 폴더가 클래스를 나타내도록 구축되어있다면 굳이, 생성기 클래스를 만들 필요는 없습니다. 자신의 학습 모델 데이터에 맞게 활용하시기 바랍니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] PyQt에서 마우스 버튼 클릭 반응형 효과 만들기

주식회사 딥아이 — Fri, 12 Mar 2021 12:52:22 +0900

Concept

그림 1. 윈도우 환경에서 적용되는 다양한 마우스 커서 효과

PC 환경에서 마우스는 이제 대체할 수 없는 강력한 UI 도구입니다. 모바일과 같이 NUI를 적용하려는 다양한 시도가 있었지만, 아직까지 대체 불가능인 것 같습니다.

우리는 프로그램에서 버튼을 클릭할 때 마우스 커서를 버튼 UI에 올려 놓게되며, 이때 커서의 반응 효과를 통해 클릭이 가능한 버튼은지, 클릭이 된 건지를 판단합니다. PyQt에도 기본적으로 버튼의 클릭 이벤트는 CSS로 구현되지만, 마우스의 효과는 코드를 통해 구현되고 있습니다.

SourceCode

def initUI(self):
    # 버튼 생성
    self.BUTTON = QPushButton(self)
    # 버튼 커서 이벤트 지정
    self.BUTTON.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))

그림 2. QT에서 지원하는 기본 커서 목록

그림 2와 같이 기본적인 커서를 qt에서 지원하고 있습니다. 파이썬 환경의 경우, ::을 .으로 변경하여 코드 QtGui.QCursor()에 넣어주시면 됩니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Matlab] 복셀화 (Voxcelization)을 이용한 LIDAR 라이다 PCD 데이터 압축 #4

주식회사 딥아이 — Wed, 10 Mar 2021 17:03:21 +0900

Concept

그림 1. 실시간으로 수집되는 점 구름 데이터

지난 포스팅에 이은 라이다 데이터 전처리 기법 #4 , PCD Voxcelization 알고리즘입니다.

3차원 희소 데이터 특성을 가지는 라이다 PCD는 채널 수에 따라 다르지만, 10,000 ~ 1,000,000 개 이상의 데이터가 초 단위로 수집됩니다. 단순한 3차원 float 형의 공간 정보이지만, 10,000 개 이상의 데이터를 실시간으로 전 처리하고 알고리즘에 활용하기에는 효율성이 매우 떨어집니다.

특히, 차량이나 드론과 같은 이동체에서 자율주행을 위해 활용될 경우, 연구소 환경과 같은 고성능 워크스테이션에서의 연산이 불가능 하기에 다양한 기법으로 데이터를 압축시키거나 효율적으로 연산하는 방법들이 제안되고 있습니다.

최신 기법은 아니지만, 비교적 쉽고 현재까지 활용되고 있는 Voxcelization 기법을 매트랩으로 구현해보도록 하겠습니다.

POST

1.라이다 데이터 전처리 [KITTI DATASET 활용하기]

2. 각도에 따라 라이다 데이터 분할하기 [Segmentation]

3. 변환 행렬을 이용하여 라이다 데이터 축 변환하기 [Transformation]
4. 복셀화를 이용한 LIDAR 라이다 PCD 데이터 압축 [Voxcelization]

Algorithms

그림 2. 복셀 크기에 따른 모델링

복셀화는 2차원적인 픽셀(Pixcel)을 3차원의 형태로 구현한 것을 정의하며 Volume+ Pixcel의 합성어로, 부피를 가진 픽셀이라 할 수 있습니다. 컴퓨터 비전이나 3차원 모델링 분야에서 랜더링을 위해 사용되는 기술이며, 우리에게 친숙한 마인 크래프트 역시 복셀화로 랜더링 된 게임입니다.

PCD 복셀화는 이 아이디어를 착안하여, 지정한 복셀의 크기 (가로 X 세로 X 높이) 안에 포함된 PCD 데이터를 하나의 값으로 압축하는 알고리즘으로 제안되었습니다. 기존 영상 히스토그램화와 같이 기본적인 연산만으로도 쉽게 압축되는 것이 장점입니다.

또한, 수집되는 데이터는 Float 형태로 저장되어 0.125486212과 같이 아날로그 신호 특성을 가지고 있지만 복셀화를 진행하면 정규화와 이산 신호 형태로 변환되어 이후 연산량에서도 효율성을 높일 수 있습니다.

그림 3. N x N 의 복셀로 PCD를 압축

SourceCode

1. SourceCode 및 샘플 데이터 다운로드

github.com/DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

Pre-processing Technique of LIDAR PCD Data Using KITTI-Dataset - DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

github.com

git clone github.com/DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

2. 히스토그램 생성 함수로 영역 분할하기

% 2D Voxcelization
w = 200;
h = 200;
[count2D, ~, ~, ~] = histcn(xyzi(:,1:2), w , h);

% 3D Voxcelization
w = 200;
h = 200;
ch = 50;
[count3D, ~, ~, ~] = histcn(xyzi(:,1:3), w , h, ch);

readPCD 파일 내 전처리 함수를 모두 실행한 뒤, 복셀화를 시작합니다. 매트랩에서 복셀화는 histcn 함수를 통해 진행합니다. histcn 함수는 주어진 데이터를 W x H x CH의 영역으로 분할하여 내부에 포함된 데이터의 개수를 출력하는 함수입니다.

예를 들어 입력으로 w와 h를 200으로 지정하면, 전체 PCD의 개수를 200x200 = 40,000 만큼의 크기로 압축이 됩니다.

3. Histcn 값을 정렬하여 원본 PCD값과 1대 1 대응하기

function [transX2D] = voxcelization2D(count3D)
  [x2D,y2D] = find(count3D);
  transX2D = [x2D, y2D];
end

function [transX3D] = voxcelization3D(pcd,count)
s = 1;
for k =1:count
        if(k==1)
            [x3D,y3D,z3D] = find(pcd(:,:,k)) ;
            transX3D =[x3D, y3D,repmat(s,size(x3D,1),1)] ;
        else
            [x3D,y3D,z3D] = find(pcd(:,:,k)) ;
            transX3D = [transX3D ; x3D, y3D, repmat(s,size(x3D,1),1)];
        end
        s = s + 1;
end

이후, voxcelization2D, 3D 함수를 통해 0의 값을 제거하면 유효한 복셀 값만 남게 됩니다. 남은 복셀의 인덱스를 X축과 Y축 인덱스로 추출하면 2차원 복셀화, Z 축까지 추출하면 3차원 복셀 화가 완료됩니다.

그림 4. (위) 원본 (아래) 압축

Reference

Birdnet: a 3d object detection framework from lidar information

[Python] SORT (Simple Online Real time Tracker) 구현하기 (깃허브 소스 코드)

주식회사 딥아이 — Fri, 26 Feb 2021 14:27:08 +0900

Concept

컴퓨터 비전 분야에서 응용되는 대표적인 딥러닝 기술은 객체 탐지(Object Detection)입니다. 객체 탐지는 Faster-RCNN, SDD, YOLO 등이 제안되면서 최근 객체 탐지 기술은 꽤 높은 수준으로 상향 평준화되어있습니다.

탐지 기술은 발전하고 있지만, 단순히 객체를 탐지하는 수준으로는 실제 상업적인 비즈니스 단계에서 활용성이 높지 않습니다. Application을 위해 객체를 추적(Tracking) 하고, 인식(Identification) 하고, 객체의 행동(Action Recognition)을 판단하는 기술들이 더해지고 있습니다.

다양한 응용 기술 중에서 탐지된 객체를 추적하고 아이디를 부여하는 Tracking 기술을 다뤄보려 합니다. 이번 포스팅은 다중 객체 탐지 (Multi-Object Tracking)의 뼈대가 된 SORT 알고리즘입니다.

Algorithm

논문 : Simple online and realtime tracking

CPU 환경에서의 실시간 동작을 위한 딥러닝 기반 다중 객체 추적 시스템 논문 자료

SORT는 탐지된 객체의 경계상자를 이용하여 객체의 속도를 칼만 필터 (Kalman Filter)로 추정하여 다음 프레임에서 객체의 위치를 예측하는 방식으로 사용됩니다.

예를 들어, N번째 프레임에서 탐지된 경계상자 F는 칼만 필터로 N+1 번째 프레임에서의 F*를 추정하게 됩니다. 여기서 N+1 번째 프레임에서 새롭게 탐지된 객체 정보 F'와 예측된 F*의 유사도를 IOU의 거리값 그리고 헝가리안 알고리즘 등을 통해 정렬하고 매칭하여 N 번째에서 탐지된 객체의 정보를 N+1에서 이어나갈 수 있게 합니다.

심플한 아이디어지만 빠른 속도와 실시간 가능성을 확보할 수 있으며, 객체 탐지 단계에서 탐지율이 보장만 된다면 기본적인 객체 트레킹 성능은 보장되는 장점을 가지고 있습니다.

SourceCode

github.com/abewley/sort.git

abewley/sort

Simple, online, and realtime tracking of multiple objects in a video sequence. - abewley/sort

github.com

git clone https://github.com/abewley/sort.git
cd sort
pip install -r requirements.txt

MOT15 TEST SET 평가 데이터 검증하기

깃허브 소스 파일에 MOT15의 DET 데이터를 포함하고 있으므로, 코드 수정없이 sort.py 코드 실행을 하면 10초 이내 전체 데이터에 대한 검증 결과가 output 폴더 내 txt 파일로 저장됩니다. 출력된 파일의 형식은 아래 표와같습니다.

테스트 데이터에 대한 성능평가 지표 검증은 다음 포스팅에서 정리하도록 하겠습니다.

python sort.py

frame	id	x	y	w	h	score	3D 평가 지표 (무시)
1	3640	1800	483	94	214	1	-1	-1	-1

그림 1. 출력되는 Tracking 결과값

실시간 Tracking 결과 확인하기

MOT15 데이터에 대한 Tracking 결괏값을 영상으로 확인하기 위해서는 이미지 데이터가 필요합니다. 이전 포스팅을 참고하시면 쉽게 다운로드할 수 있습니다.

deep-eye.tistory.com/66

[Python] MOT(Multi-Object Tracking) 평가를 위한 데이터 다운로드

Concept 컴퓨터 비전 기반 딥러닝 기술의 성장과 함께 객체 추적(Tracking) 알고리즘이 발전하고 있습니다. 특히, 객체 탐지 성능이 좋아지며 최근에는 단일 객체가 아닌, 다중 객체 추적 (MOT : Multi - O

deep-eye.tistory.com

SORT가 설치된 폴더 내 'mot_benchmark' 폴더를 생성 합니다. 이후, 다운로드 한 MOT15 데이터를 해당 경로에 압축해제 한 다음 명령어를 실행해주면 실시간으로 Tracking 결과가 출력됩니다.

python sort.py --display

알고리즘에 대한 자세한 설명은 여기를 참고하시면 좋을것 같습니다. SORT는 객체 속도를 예측하는 방식으로 트레킹을 시도한 알고리즘으로서, 최신 기법의 기반이 되는 기술이지만 객체의 특징을 판단하지 못한다는 점에서 겹침문제나 장애물 등으로 인한 가림 문제 등에는 대응하지 못하는 단점이 존재합니다. 다음 포스팅에서는 SORT와 함께 비교되었던 기반 알고리즘 IOU Tracker를 소개하겠습니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Tensorflow] 분류기 학습을 위한 One-Hot encoding 라벨 생성하기

주식회사 딥아이 — Wed, 24 Feb 2021 16:27:21 +0900

Concept

softmax / cross entropy 를 이용한 신경망 분류기 학습에는 일반적으로 One-Hot Encoding (원-핫 인코딩)된 라벨 데이터를 많이 활용합니다. 텐서플로우는 쉽게 라벨 생성을 위한 함수를 제공하고 있습니다.

SourceCode

Index 라벨 데이터 one hot incoding

MNIST의 경우, 라벨은 1차원으로 나열되어있으며 0은 0, 1은 1, ... , 9는 9로 인덱싱되어있습니다. 이를 원 핫 인코딩하면 다음과 같습니다.

여기서 on_value는 활성화된 값, off_value는 비활성값입니다. 일반적으로 1과 0으로 설정하면 됩니다. 만약 라벨 인덱스에 0 이하 값이 포함되어있다면, 값 설정이 혼돈될수 있기때문에 최소값을 0 이상으로 설정한 뒤 인코딩해주세요.

import tensorflow as tf

# 목표 라벨 개수 ex) mnist 10개, cifar-100 100개
label_size = 10

# one - hot encoding
label_one_hot = tf.one_hot(label_index, label_size,
                       on_value=1.0, off_value=0.0)

one hot incoding 라벨 데이터를 단일 Index로 decoding

인코딩된 값으로 학습하면 학습된 결과값 역시 인코딩된 방식으로 예측됩니다. 이를 다시 단일 Index로 변환하려면 argmax를 활용하면 됩니다.

prediction = model.predict(test_data)
index = tf.argmax(prediction, axis=1)

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] MOT(Multi-Object Tracking) 평가를 위한 데이터 다운로드

주식회사 딥아이 — Tue, 23 Feb 2021 13:38:16 +0900

Concept

컴퓨터 비전 기반 딥러닝 기술의 성장과 함께 객체 추적(Tracking) 알고리즘이 발전하고 있습니다. 특히, 객체 탐지 성능이 좋아지며 최근에는 단일 객체가 아닌, 다중 객체 추적 (MOT : Multi - Object Tracking) 이 주요 과제로 자리하고 있습니다.

최근 MOT의 트렌드는 CNN 기반 특징맵, 예측 필터, 그래프 모델 등을 융합하는 방식으로 성능을 향상시키고 있으며, 이와 관련된 다양한 평가 데이터가 공개되어있습니다.

현재 작성중은 논문을 정리하면서, 알고리즘과 데이터를 포스팅으로 남기려 합니다. 이번 포스팅은 MOT 성능평가로 활용되는 대표적인 데이터 MOT Challenge Dataset을 다운받는 기본적인 방법입니다.

MOT Dataset

motchallenge.net/

MOT Challenge

In the recent past, the computer vision community has relied on several centralized benchmarks for performance evaluation of numerous tasks including object detection, pedestrian detection, 3D reconstruction, optical flow, single-object short-term tracking

motchallenge.net

MOT Challenge 데이터는 현재 많은 학회에서 경쟁 데이터로 활용되고 있으며, 홈페이지에 데이터 다운로드는 물론, 알고리즘에 따른 평가 결과를 직관적으로 확인할 수 있습니다.

MOT 데이터는 연도별로 추가되거나 수정된 버전이 나눠져있습니다. 대표적인 데이터는 표와 같습니다.

DATASET	MOT15	MOT16	MOT17	MOT20
TRAIN SET	프레임: 5000 트랙 : 500 경계상자 : 39905 밀도 : 7.3	프레임: 5316 트랙 : 517 경계상자 : 110407 밀도 : 20.8	프레임: 15948 트랙 : 1638 경계상자 : 336891 밀도 : 21.1	프레임: 8931 트랙 : 2332 경계상자 : 1336920 밀도 : 149.7
TEST SET	프레임: 5783 트랙 : 721 경계상자 : 61440 밀도 : 10.6	프레임: 5919 트랙 : 759 경계상자 : 182326 밀도 : 30.8	프레임: 17757 트랙 : 2355 경계상자 : 564228 밀도 : 31.8	프레임: 4479 트랙 : 1501 경계상자 : 765465 밀도 : 170.9
DETECTOR	ACF-based Detector	ACF-based Detector Faster-RCNN DPM	SDP Faster-RCNN + DPM +	Faster R-CNN ++
Download	데이터 (1.3GB) 클래스 (3.7MB)	데이터 (1.9GB) 클래스 (3.2 MB)	데이터 (5.5GB) 클래스 (9.7MB)	데이터 (5.0GB) 클래스 (13.9MB)

최신 MOT 데이터가 평가에 좋은건 아닙니다. 데이터 마다 서로 다른 특징과 중점으로 해결하고자하는 문제가 있으니 보다 자세한 사항은 홈페이지 또는 데이터 논문을 참고하시기 바랍니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] PyQt5에서 URL 링크 만들기 (하이퍼링크 버튼)

주식회사 딥아이 — Tue, 23 Feb 2021 00:38:34 +0900

Concept

이번 포스팅은 pyqt 기반 GUI 프로그램에서 활용 가능한 URL 링크 버튼 만들기 입니다. URL 링크는 webbrowser 라이브러리를 QtButton과 연동하여 웹 페이지 링크를 실행하는 방식으로 구현됩니다.

SourceCode

import webbrowser

class APP(QMainWindow):
    def __init__(self):
    
    # APP CODE
    # APP CODE
    
    # 버튼에 링크 추가하기
    self.button.clicked.connect(lambda: webbrowser.open('링크'))
    
    # 텍스트 (라벨)에 링크 추가하기
    self.label.setText('<a href="링크">텍스트내용</a>')
    self.label.setOpenExternalLinks(True)

Application

스터디 위드디 프로그램 링크

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Tensorflow] K-Fold 교차 검증으로 학습 모델 검증하기 (sklearn)

주식회사 딥아이 — Sun, 21 Feb 2021 14:01:03 +0900

Concept

K-Fold Cross Validation (K 폴드 교차 검증)은 데이터 수가 적을 때, 보다 확실한 검증과 정확도 향상을 위해 사용되는 검증 기법입니다.

파이썬 sklearn 라이브러리에는 K-Fold를 쉽게 정의해주는 함수를 포함하고 있습니다.

from sklearn.model_selection import KFold

# K-FOLD 정의
nb_split = 5 # 분할 개수
KF = KFold(n_splits=n_split, shuffle=True)

정의한 이후, 학습 단계에서 for문으로 데이터를 분할하면 됩니다. 예를 들어 pandas로 입력된 DataFrame 데이터는 다음과 같이 데이터가 k-fold로 나뉘게 됩니다.

for train_idx, valid_inx in kf.split(train_data):

    # 학습 데이터
    train_in = train_data.iloc[train_idx]
    # 검증 데이터
    valid_in = train_data.iloc[valid_inx]

이후 단계는 기존 알고리즘 학습과 동일합니다. 평균 성능 검증을 위해선 분할된 만큼 개별적으로 검증 데이터로 검증되어야 하며 최적 가중치 역시 개별적으로 학습되어야 하기때문에 기존 학습 대비 K배 만큼의 시간이 더 소요됩니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Tensorflow] GAN (생산적 적대 신경망) 구현하기

주식회사 딥아이 — Wed, 17 Feb 2021 11:15:36 +0900

Concept

그림 1. GAN 2.0: NVIDIA’s Hyperrealistic Face Generator 생성된 가짜 이미지

요즘 가장 흥미롭게 연구 중인 GAN (Generative Adversarial Network: 생산적 적대 신경망)입니다. GAN은 Neural Network에 뿌리를 두고 있으나 비지도 학습으로 정의되며, 두 개의 신경망이 서로 경쟁하며 학습하게 됩니다. 2014년 처음 아이디어가 제안된 이후, 급격한 연구적 성장을 거듭하며 현재는 놀라울 정도로 진보된 기술로 성장하고 있습니다.

이번 포스팅에서는 GAN의 오리지널 버전의 알고리즘을 간단하게 살펴본 뒤, MNIST 손글씨 인식 데이터를 이용해 텐서플로우로 구현해보도록 하겠습니다.

Algorithm

그림 2. GAN 신경망의 기본 구조

기본적인 구조는 간단합니다. 가짜 이미지 생성을 위한 생성자(Generator) 신경망과 진짜와 가짜 이미지 판별을 위한 판별자(Discriminator) 신경망으로 구성됩니다. 두 신경망 모두 FC(Fully Connected Layers)로 구성된 다층 신경망입니다.

1. 생성자 네트워크

비지도 학습으로 정의되는 GAN의 생성자는 임의로 생성된 잡음을 입력으로 영상을 생성합니다. 보통 1 x 100 ~ 200의 잡음을 입력하며, 기존 MLP와 동일하게 2 ~ 3개의 층으로 구성된 네트워크로 설계하면 됩니다.

MNIST 데이터를 목표할 경우, 28 x 28의 이미지 크기에 맞게 1 x 768의 출력층을 가지게 됩니다. CNN 구조가 없기 때문에 2차원 데이터를 모두 1차원으로 변경해주어야 합니다.

2. 판별자 네트워크

생성자 네트워크와 역순으로 설계됩니다. 1 x 768이 입력되며 신경망 층을 통해 최종적으로 참 (1) 과 거짓 (0)을 판단하게 됩니다. 손글씨 인식을 위한 분류 네트워크와 같은 구조이며 출력은 1개입니다.

3. 손실 함수

GAN은 일반적으로 판별자 네트워크 기반 크로스 앤트로피 손실 함수를 통해 학습하게 됩니다.

생성자 네트워크 (G)는 거짓 이미지가 판별자 네트워크에 입력되었을 때 값이 최소 (MIN)가 되도록 하며 (거짓 이미지가 거짓인지 모르도록), 판별자 네트워크 (D) 는 거짓 이미지와 참 이미지가 판별자 네트워크에 입력되었을 때 값이 최대 (MAX) (거짓을 거짓으로 참을 참으로 판별하도록)가 되도록 학습하게 됩니다.

이처럼 서로 반대되는 방향으로 학습되는 구조이기때문에, 경쟁학습 이라고도 하며 Zero-Sum 게임과 유사합니다.

SourceCode

github.com/DEEPI-LAB/python-tensorflow-MNIST-GANs.git

DEEPI-LAB/python-tensorflow-MNIST-GANs

Contribute to DEEPI-LAB/python-tensorflow-MNIST-GANs development by creating an account on GitHub.

github.com

git clone https://github.com/DEEPI-LAB/python-tensorflow-MNIST-GANs.git

1. MNIST 데이터 불러오기

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

from scipy import io

mnist_x = io.loadmat('train_input.mat')['images']
minst_y = io.loadmat('train_output.mat')['y']
mnist_x = mnist_x.astype('float32')

2. 생성자 네트워크 구조 설계

저는 은닉층과 입력의 갯수를 맞추기 위해 256개의 노이즈를 생성했습니다. 100개나 200개나 크게 다르지는 않습니다. 활성화 함수는 relu를 사용하였으며 출력단에는 선형회기 예측과 같은 메커니즘이므로, 시그모이드 활성화 함수를 사용합니다.

# Generator
Generator = tf.keras.Sequential([
    tf.keras.layers.Input(256,30),
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dense(784, activation='sigmoid')])

3. 판별자 네트워크 구조 설계 및 Optimizer 정의

# Discriminator
Discriminator = tf.keras.Sequential([
    tf.keras.layers.Input(784),
    tf.keras.layers.Dense(256, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')])

# define Optimizer
Doptimizer = tf.keras.optimizers.Adam(0.001)
Goptimizer = tf.keras.optimizers.Adam(0.001)

4. 학습 모델 생성

텐서플로우는 버전에 따라 다양한 학습 방법이 존재합니다. tessorflow 2.0 이상 버전에서 작성하였으며, 2개의 신경망 학습이 진행되야하기때문에 두개의 손실함수를 업데이트 해주는 방식으로 코드를 구현합니다.

#%% Training Step
def get_noise(batch_size,n_noise):
    return tf.random.normal([batch_size,n_noise])

@tf.function
def train_step(inputs):

    with tf.GradientTape() as t1, tf.GradientTape() as t2:
        # 잡음으로부터 이미지 생성
        G = Generator(get_noise(30,256))
    	# 판별자 입력
        Z = Discriminator(G)
        R = Discriminator(inputs)   
        # 손실 함수 연산
        loss_D = -tf.reduce_mean(tf.math.log(R) + tf.math.log(1 - Z))
        loss_G = -tf.reduce_mean(tf.math.log(Z))
    
    # 판별자 업데이트      
    Dgradients = t1.gradient(loss_D, Discriminator.trainable_variables)
    Doptimizer.apply_gradients(zip(Dgradients, Discriminator.trainable_variables))
    # 생성자 업데이트
    Ggradients = t2.gradient(loss_G,Generator.trainable_variables)
    Goptimizer.apply_gradients(zip(Ggradients, Generator.trainable_variables))

5. 신경망 학습

학습에 따라 생성된 이미지를 확인하기 위해 plot으로 이미지를 확인하는 구문을 추가할 수 있습니다.

# 배치 사이즈
total_batch = int(60000/30) 
        
for epoch in tf.range(15):
    k = 0
    for i in tf.range(total_batch):
        batch_input = mnist_x.T[i*30:(i+1)*30]
    
        inputs = tf.Variable([batch_input],tf.float32)
        train_step(inputs)
        print(k)
        k = k + 1
		
        # 생성된 이미지
        if k%100 == 0:
            G = Generator(get_noise(10,256))
        
            fig, ax = plt.subplots(1,10 ,figsize=(10, 1))
                
            for j in range(10):
                ax[j].set_axis_off()
                ax[j].imshow(np.reshape(G[j], (28, 28)).T,cmap='gray')
            plt.pause(0.001)
            plt.show()

6. 학습 결과

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Linux] 우분투에서 파일 복사 불어넣기 안될때 해결 방법 (폴더 권한 설정)

주식회사 딥아이 — Tue, 9 Feb 2021 10:35:49 +0900

리눅스 환경에서 갑자기 파일 속성이 read-only 로 변하거나 코드 수정 등이 안되는 경우가 있습니다. 디스크를 위험으로부터 보호하기위해 자동으로 변경되는거라고 합니다. 특히, 멀티 부팅으로 같은 파이션 내 파일을 작업할때 자주 발생합니다.

솔루션은 간단합니다. 다시 권한설정을 부여 할 파티션 또는 폴더의 경로를 다시 마운트하면 됩니다.

# RE-MOUNT 
mount -o remount,rw/"절대경로"

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] 파이썬에서 매트랩 MAT 파일 읽기 (scipy)

주식회사 딥아이 — Sat, 6 Feb 2021 18:38:59 +0900

Concept

사실 저는 학+석사 시절, 매트랩을 품에 안고 살았기때문에 한글보다 매트랩 문법 읽는게 편했습니다.? 그러다보니 아직까지도 데이터를 확인하고 분석하는데 매트랩을 자주 이용하는 편입니다.

데이터를 전처리하거나 시각화 과정에서 파이썬과 매트랩 이동이 많은데 고맙게도 python의 scipy 라이브러리에서 매트랩 데이터 저장 형식 파일을 읽기를 지원하고 있습니다.

SourceCode

Scipy 설치

pip install scipy

mat 파일 읽기

from scipy import io

# 데이터 파일 불러오기
mat_file = io.loadmat('mnist_train.mat')

# 특정 변수 읽기
input_x = mat_file['x']
target_y = mat_file['y']

mat 파일 쓰기

import numpy as np
from scipy.io import savemat

# mat 파일 저장하기
result_x = np.arange(5000)
# 변수명 지정하기 (dic 타입)
mat_dic = {"x": result_x , "label": "1st train"}
# 저장
savemat("test_result.mat", mat_dic)

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Pytorch] SlowFast Network 구현하기 (FAIR 소스 코드)

주식회사 딥아이 — Sat, 6 Feb 2021 17:56:28 +0900

그림 1. Slow path와 Fast path를 통한 End-To-End 학습 구조를 가지는 SlowFast

Concept

이번 포스트는 CVPR2019 AVA Challenge 행동 인식 분야에서 혁신적이고 뛰어난 성능으로 1등을 차지한 SlowFast Network의 오픈소스 코드 구현입니다. 비즈니스에서 페이스북이 최고다를 논하지는 않지만, 정말 인공지능 분야 연구에서만은 대단합니다.

FAIR 그룹에서 제안된 SlowFast 알고리즘의 저자 중엔 그 유명한 Kaiming He가 또! 포함되어 있습니다. 기회가 닫는다면 한번 같이 일해보고 싶네요... 핵심 아이디어는 단순하지만 깊이가 있는 알고리즘이기 때문에 본 포스팅에서는 간단하게 개념을 살펴본 뒤, 코드를 구현하도록 하겠습니다. SlowFast는 FAIR 깃허브에서 오픈소스로 공개되고 있습니다.

github.com/facebookresearch/SlowFast

facebookresearch/SlowFast

PySlowFast: video understanding codebase from FAIR for reproducing state-of-the-art video models. - facebookresearch/SlowFast

github.com

Algorithm

이전의 제안된 행동 인식 알고리즘들은 '움직임'을 해석하기 위해 Optical Flow와 같은 컴퓨터 비전 기술들을 융합하는 방식으로 설계되었습니다. 기반이 되는 네트워크는 CNN, LSTM 등과 같이 다르지만 영상 이외에 추가적인 융합이 트렌드였습니다. SlowFast는 Optical Flow를 사용하지 않는 단일 영상 기반 알고리즘이며 영장류가 객체의 행동을 인식하는 신경 메커니즘에서 영감을 받아 설계되었다고 합니다.

그림 2. 기존 행동 인식 네트워크의 일반적인 구조

이로써, 객체 행동 인식 분야에서도 End-To-End 학습만으로 가시적인 성과를 달성하게 되었습니다. 또한 높은 성능으로 관련 평가 데이터셋에서도 3년이 지난 지금까지도 상위에 랭크되어 있습니다. 다시 한번 FAIR에 무한한 경외감이 듭니다. 논문과 알고리즘에 대한 상세 리뷰는 많은 분들께서 높은 퀄리티의 포스팅을 해주셨습니다. 링크를 참고해주시면 될 것 같습니다.

chacha95.github.io/2019-07-20-VideoUnderstanding6/

SlowFast Networks 리뷰

이번 포스트에서는 CVPR2019 워크숍에서 열린 AVA challenge의 한 topic인 AVA challenge의 Action 분야에서 1등을 차지한 SlowFast Networks에 대해 알아보겠습니다. 또한 이 논문은 ICCV2019에 oral 발표 예정입니다.

chacha95.github.io

openaccess.thecvf.com/content_ICCV_2019/html/Feichtenhofer_SlowFast_Networks

ICCV 2019 Open Access Repository

Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, Kaiming He; Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2019, pp. 6202-6211 We present SlowFast networks for video recognition. Our model involves (i) a Slow pathway, o

openaccess.thecvf.com

SourceCode

리눅스 우분투 18.04 버전에서 최종 설치와 구현 모두 완료하였습니다. 기본 설치 환경은 표와 같습니다.

운영체제	그래픽카드	그래픽카드 버전	CUDA & cuDNN	파이썬
우분투 18.04	Nvidia RTX 3090	460.32.03	11.2 / 8.0.5	Python 3.8

1. 기본 패키지 설치

기본적인 설치 과정은 SlowFast 깃허브 링크를 참조하셔도 좋습니다.

충돌 방지를 위해 가상 환경을 생성해줍니다. 본 포스팅은 파이썬 3.8 버전을 기준으로 작성되었습니다.

이후, 본인의 그래픽 카드와 쿠다 버전에 맞는 pytorch (최소 1.3 ver 이상)를 설치해줍니다. pytorch 공홈에서 쉽게 다운로드할 수 있습니다. 파이토치 설치가 완료되면 순차적으로 필수 패키지를 설치해줍니다.

객체 탐지와 객체별 행동 분석을 위해서는 Detectron2 설치는 필수인 것 같습니다.

pip install torch==1.7.1+cu110 torchvision==0.8.2+cu110 torchaudio===0.7.2 -f https://download.pytorch.org/whl/torch_stable.html

1-1. 의존성 패키지 설치 (1/2)

pip install 'git+https://github.com/facebookresearch/fvcore'
pip install simplejson

1-2. 의존성 패키지 설치 (2/2)

conda install av -c conda-forge
pip install -U iopath
pip install psutil
pip install opencv-python
pip install torchvision
pip install tensorboard
pip install moviepy

1-3. Detectron2 설치 (1/2)

pip install cython
pip install -U 'git+https://github.com/facebookresearch/fvcore.git' 'git+https://github.com/cocodataset/cocoapi.git#subdirectory=PythonAPI'

1-4. Detectrion2 설치 (2/2)

git clone https://github.com/facebookresearch/detectron2 detectron2_repo
pip install -e detectron2_repo

2. SlowFast 설치

2-1 slowfast 환경변수 설정하기

필수 패키지가 모두 설치되었다면, slowfast를 깃허브 링크를 통해 clone 해줍니다. 완료되면 slowfast 폴더를 파이썬 환경변수로 지정해야 합니다. nano 에디터에서 bashrc를 실행해주세요.

git clone https://github.com/facebookresearch/slowfast

sudo nano ~/.bashrc # bash 파일 수정
source ~/.bashrc    # bash 파일 수정 후

최하단에 slowfast 경로를 추가한 다음, 컨트롤 + X 후 Y를 눌러 저장해줍니다. 이후 source ~/. bashrc를 입력해주세요. 환경변수 설정이 완료되었다면 실행 중인 터미널을 종료한 뒤, 다시 실행해주세요.

export PYTHONPATH="slowfast 절대 경로":$PYTHONPATH

2-2 slowfast 빌드하기

cd SlowFast
python setup.py build develop

RunDemo (Kinetics version)

slowfast 빌드까지 모두 완료되었다면 데모 실행을 위한 모든 준비는 끝입니다. 이제, 사전 학습된 가중치 파일을 기반으로 실시간 영상 또는 웹캠에서 행동을 인식해보도록 하겠습니다. 간단한 데모 실행 과정이 약간 복잡하게 되어있어 약간 우회하여 접근해야 합니다. 다소 복잡하더라도 천천히 따라오시면 됩니다.

KInetics 목록 하단에서 3번째 위치한 "Kinetics/c2/SLOWFAST_8x8_R50"를 받아줍니다.

가중치 파일 링크 : github.com/anhminh3105/SlowFast/blob/master/MODEL_ZOO.md

anhminh3105/SlowFast

PySlowFast: video understanding codebase from FAIR for reproducing state-of-the-art video models. - anhminh3105/SlowFast

github.com

데모 실행을 위한 Config 파일 및 파이썬 소스코드 다운로드

데모 실행을 위한 yaml 파일과 run.py 오류가 수정된 slowfast 데모 버전 파일을 clone 해줍니다.

git clone -b prediction_demo https://github.com/anhminh3105/SlowFast.git
cd SlowFast

새롭게 받은 SlowFast 폴더 내 configs/Kinetics/demo의 경로에 다운로드한 가중치 파일을 옮겨줍니다. 실행을 위해서는 클래스 라벨 파일. cvs, config 파일. yaml, 가중치 파일. pkl 이 필요합니다.

yaml 파일을 열어 TEST.CHECKPOINT_FILE_PATH 항목에 다운로드한 가중치 파일의 경로를 입력해줍니다. 코드를 실행하면서 가중치 경로를 함께 입력한다면 수정하지 않아도 됩니다.

TEST:
  ENABLE: False
  DATASET: kinetics
  BATCH_SIZE: 16
  CHECKPOINT_TYPE: caffe2
  CHECKPOINT_FILE_PATH: "./configs/Kinetics/demo/SLOWFAST_8x8_R50.pkl"

이제, 웹캠을 연결한 뒤 slowfast 상위 경로에서 명령어를 입력하면 됩니다.

python ./tools/run_net.py --cfg ./configs/Kinetics/demo/SLOWFAST_8x8_R50.yaml

실행 과정에서 model_builder.py 오류가 난다면, bashrc 실행을 통해 기존 slowfast경로 이외에 추가로 다운로드 한 데모 버전 slowfast 경로를 추가하면 됩니다.

사실 SlowFast의 진가는 그림 3과 같이 객체를 탐지한 뒤, 객체의 행동을 독립적으로 인지 하는 것이라고 생각합니다. 일반화하기에는 다소 무리가 있지만, 요즘 AI 행동인지 기술은 연구하고 공급하는 분야에서 SlowFast는 국룰인것으로 알고 있습니다... 하지만,

본 포스팅에서 구현된 결과는 전체 화면을 하나의 입력 프레임으로 하기 때문에 객체의 크기가 너무 크거나 작으면 인식 정확도가 낮아진다는 단점이 있죠.

그림 3. AVA DATASET 평가 결과

오픈 소스라는 넘사벽 이로움은 있지만, 사용 환경에 맞게 최적화하기가 조금은 까다롭게 제공되는 것 같습니다. 하나의 포스팅으로 정리가 안되네요.

다음 포스팅에서는 Detectron2 + Slowfast 구현, 학습 및 다양한 상황별 활용 가능한 코드를 정리하겠습니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Tensorflow] RTX 3000 시리즈에 텐서플로우 2.5 및 CUDA 11 설치하기

주식회사 딥아이 — Mon, 1 Feb 2021 11:53:52 +0900

Concept

[2021-01-31]

2020년 9월 출시한 RTX 3000 시리즈는 공식적으로 CUDA 11 버전 이상을 지원하고 있습니다. 이에 맞는 텐서플로우 설치가 아직까지 안정화 문제인지 최적화되지 않은 상황입니다. 저는 Nightly (개발 버전)의 텐서플로우 설치를 통해 윈도우 환경에서 구축되어 포스팅을 남깁니다.

Environment

운영체제	그래픽 카드	그래픽 카드 드라이버 버전
Window 10	RTX 3090	461.40

1. 가상환경 생성하기

가상환경을가상 환경을 생성하는 단계는 이전 포스팅과 동일합니다. 아나콘다를 이용하여 파이썬 3.8 기반 가상 환경을 생성해줍니다.

deep-eye.tistory.com/7

[Tensorflow] 아나콘다 가상환경에서 텐서플로우 설치하기

2019년 말, 텐서플로우 2.0 버전이 배포되면서 머신러닝 분야에서 텐서플로우의 열기는 더욱 더 뜨거워졌습니다. 새로워진 텐서플로우 설치를 시작으로 CNN (Convolutional Neural Network) 기반의 이미지

deep-eye.tistory.com

2. CUDA 설치하기

CUDA 11.1 버전 다운로드 링크 : CUDA Toolkit 11.1 Update 1 Downloads

CUDA Toolkit 11.1 Update 1 Downloads

Please Note: We advise customers updating to Linux Kernel 5.9+ to use the latest NVIDIA Linux GPU driver R455 that will be available for download from NVIDIA website and repositories, starting today. Select Target Platform Click on the green buttons that d

developer.nvidia.com

CUDA 11.1 버전 설치를 진행해줍니다. EXE (Local) 파일이 용량이 크지만 전체를 다운받아 설치를 진행하기 때문에 체감상 좀 더 빠르게 설치가 진행되는 듯합니다. 설치가 진행되는 동안 cuDNN을 다운로드 합니다. cuDNN은 엔비디아 개발자 로그인이 요구되기 때문에 아이디가 없다면 회원가입이 필요합니다.

로그인 후, 최상단의 " Download cuDNN v8.0.5 (November 9th, 2020), for CUDA 11.1 "를 클릭한 다음, 윈도우 버전을 다운로드해줍니다.

cuDNN 8.0.5 버전 다운로드 링크 : cuDNN Archive

cuDNN Archive

NVIDIA cuDNN is a GPU-accelerated library of primitives for deep neural networks.

developer.nvidia.com

2. 환경변수 설정하기

CUDA 설치와 cuDNN 다운로드가 모두 완료되면 cuDNN을 CUDA 설치 폴더에 적용해야 합니다. cuDNN을 압축 해제한 다음, CUDA가 설치된 폴더에 복사 불어넣기 해줍니다. 일반적으로 C://Program Files에 설치됩니다.

cuDNN 복사가 완료되었다면, 환경변수를 설정해주어 CUDA가 설치된 폴더의 위치를 알려줘야 합니다. 윈도우 검색 창에 시스템 환경 변수를 입력하면 빠르게 찾을 수 있습니다.

시스템 변수 항목에서 PATH 변수를 더블 클릭해줍니다.

환경 변수를 추가하는 방법은 간단합니다. 새로 만들기 클릭 후, 찾아보기를 통해 위치를 지정해주면 됩니다. CUDA가 설치되면서 자동으로 변수가 설정되지만, 일부 누락이나 오류를 방지하기 위해 경로가 없을 경우 경로 리스트를 모두 추가해줍니다.

CUDA 환경 변수

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.1\bin

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.1\libnvvp

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.1

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.1\lib

3. Tensorflow 설치하기

이제 마무리 단계입니다. 공식적으로 안정화된 텐서플로우는 2.3 버전이지만, 아쉽게도 CUDA 11 이상 버전에서는 2.5 버전의 개발자 버전만을 지원하고 있습니다. PIP 명령어로 Tensorflow를 설치합니다.

tf-nightly 2.5 (2021.01.10)을 다운로드하였지만, 이후 버전도 크게 문제 되지는 않을 것 같습니다.

pip install tf-nightly-gpu==2.5.0.dev20210110

# libcusolver.so.10 에러 발생 또는 GPU 연산이 안될경우 #
conda install cudatoolkit

설치가 완료되면 정상적으로 완료되었는지 확인합니다.

CMD 콘솔창 : nvcc --version 입력 [쿠다 설치 버전 확인]

가상 환경 PYTHON : import tensorflow [텐서플로우 설치 버전 및 GPU 인식 확인]

import tensorflow as tf
tf.__version__
#'2.5.0-dev20210110'

from tensorflow.python.client import device_lib
device_lib.list_local_devices()
# physical_device_desc: "device: 0, name: GeForce RTX 3090, pci bus id: 0000:01:00.0, compute capability: 8.6"

System Test

github.com/DEEPI-LAB/python-tensorflow-MNIST-GANs.git

DEEPI-LAB/python-tensorflow-MNIST-GANs

Contribute to DEEPI-LAB/python-tensorflow-MNIST-GANs development by creating an account on GitHub.

github.com

모든 설정이 완료되었다면, 약간?은 연산량이 많은 기본 알고리즘으로 테스트를 진행해봅니다. GAN 신경망 학습 알고리즘의 혁신을 불러온 DCGAN입니다. 링크를 통해 다운로드하거나 GIT으로 받아주세요.

DCGAN 알고리즘

git clone https://github.com/DEEPI-LAB/python-tensorflow-MNIST-GANs.git

DCGAN 알고리즘 의존성 패키지 다운로드

pip install pytictoc

pip install scipy

pip install matplotlib

spyder나 pycharm에서 tensorflow_DCGAN.py를 실행하거나 python tensorflow_DCGAN.py 명령어를 콘솔창에 입력하면 알고리즘 연산이 시작됩니다. 작업 관리자 성능 탭에서 CPU가 아닌 GPU의 메모리 사용량이 증가한다면 정상적으로 CUDA 프로세서가 인식된 것입니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[2021-01-29] Nvidia 3090 RTX PC 조립 (딥러닝 워크스테이션)

주식회사 딥아이 — Sat, 30 Jan 2021 16:16:03 +0900

Geforce RTX 3000 Series

PC 게임을 좋아하시거나 하이앤드 PC 환경을 구축하시는 분들에겐 작년 하반기부터 지금까지 현재 진행형으로 뜨거운 시장이 있습니다. 바로 그래픽 카드 시장이죠. Nivida에서 출시한 새로운 RTX3000 시리즈의 미친 성능 (2000시리즈 대비 30 ~ 40% 향상)으로 9월 출시되자마자 품절 대란이 일어났었습니다.

출시 5개월 전, Titan RTX 기반 학습 워크스테이션을 구입했었는데, 조금만 더 기다릴걸 후회도 했었습니다. 결국, 참지 못하고 9월 말 3090가 출시되자마자 구매를 하게 되었습니다. ㅎㅎ

GIGABTYE GAMING OC 24G RTX 3090

가격이 중요한 상황이 아닌지라 묻지도 따지지도 않고, 업체에 바로 발주를 부탁드렸었는데, 요즘 미친 가격 상황을 보니 상당히 저렴하게 구매한것같습니다. 타이탄 기반 워크스테이션이 아닌 1080TI X 2로 구성된 개인 PC를 업그레이드하기 위해 본체를 열었으나 당황하고 말았습니다. 3090 그래픽 카드가 너무나도 컸기때문이죠.

3090의 가로폭이 320mm, PC 케이스의 그래픽 카드 장착 한도도 320mm였습니다. 이론적으로는 장착이 됐지만, 여러 부품이나 케이스의 간섭으로 불가능한 상태였습니다. 허탈함을 뒤로한 채, 급한 상황이 아니니 추후 케이스를 구매하자고 의견이 모였습니다. 그리고 1월 말, 드디어 장착이 되었습니다.

PC 부품 업그레이드

딥러닝 연산에서 크게 중요하진 않지만, 간단한 컴퓨터 비전 알고리즘이나 예측 필터를 적용하는데 약간의 답답함을 개선해보고자 INTEL I9 10900F로 함께 업그레이드하였습니다. 메인보드의 경우, 오버클럭을 하지 않기에 저렴한 B460으로 구매했습니다. 오랜만에 PC 조립을 하니 시간이 조금 많이.. 걸린 것 같습니다.

Tensorflow 테스트

구글링 해보니 아직까지 3000 시리즈가 CUDA 및 Tensorflow / Pytorch 호환성이 많이 떨어진다고 하더군요. 직접적인 비교는 불가능하겠지만 간단한 성능 비교를 해보았습니다.

DCGAN - MNIST 학습

좌 : Generator 우 : Discriminator

data = 60,000 batch = 10 ep = 1
cuda 10.1 + tensorflow 2.2	cuda 10.1 + tensorflow 2.2	cuda 11.1 + tensorflow 2.5
i7 8700K + 1060 6GB	i7 8700K + 1080TI 11GB	i9 10900F + 3090 24GB
174.5 sec	112.1 sec	65.1 sec (window) / 40 sec (linux)

세부적인 사양이 달라 정확한 비교가 안될 수 있습니다. 1회 (6,000번) 학습하였을 때 연산 속도를 비교한 것입니다. 3090과 tensorflow 호환성이 아직 좋지 않아 추후 더 큰 차이가 될 수도 있을 것 같습니다. 다음 포스팅에서는 타이탄과 성능 비교를 해보도록 하겠습니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Jetson] Nvidia 젯슨 나노 (Jetson Nano) OS 설치 및 초기화 가이드

Jinsoo Kim — Wed, 27 Jan 2021 16:54:07 +0900

Jetson Nano

이번 포스팅은 라즈베리파이 시리즈와 동일하게 SD 카드로 초기화되는 젯슨 나노의 초기화 가이드 입니다.

STEP 1. OS Download

젯슨 나노는 Micro SD 메모리 카드에 운영체제(OS)를 설치한 후 카드를 꽂아서 구동합니다. 운영체제를 가지기 때문에 보드 자체를 PC처럼 사용하는 환경입니다. 먼저 하단 링크를 접속하여 [Jetson Nano Developer Kit Sd Card Image]를 다운로드합니다.

developer.nvidia.com/embedded/downloads

Jetson Download Center

Get downloadable documentation, software, and other resources for the NVIDIA Jetson ecosystem.

developer.nvidia.com

STEP 2. OS Image write

OS Image를 다운로드한 후에는 SD 카드에 이미지를 로드할 수 있는 Win32Disk Imager를 다운로드합니다.

SD Card Formatter 다운로드 URL

sourceforge.net/projects/win32diskimager/

Win32 Disk Imager

Download Win32 Disk Imager for free. A Windows tool for writing images to USB sticks or SD/CF cards . This program is designed to write a raw disk image to a removable device or backup a removable device to a raw image file. It is very useful for embedded

sourceforge.net

Win32Disk Imager를 실행한 후에 Image File에서 다운로드한 젯슨 나노 OS Image를 불러온 후 [Write] 버튼을 클릭하면 됩니다. 라즈베리파이나 윈도 부팅용 디스크 작업과 동일합니다.

STEP 3. OS Install

젯슨 나노를 부팅하기 위해 하단의 그림처럼 측면에 SD 카드를 삽입하고 Hdmi 모니터, 전원 케이블을 연결하고 남은 USB 포트에는 마우스, 키보드를 연결해주면 OS를 설치할 수 있습니다.

전원 케이블을 연결하게 되면 자동으로 젯슨 나노가 부팅되며 모니터에 화면이 출력됩니다. 이때, 모니터에 화면이 안 켜지거나 파워 점등 LED가 꺼진다면 전원을 확인해야 합니다. 젯슨 나노는 5V, 2A를 권장하고 있습니다. 기존의 구형 어댑터나 PC 연결을 통해 전원을 인가하면 전력 부족으로 시스템이 종료될 수 있습니다.

OS 설치 과정은 우분투와 동일합니다. 설정들을 완료하게 되면 젯슨 나노 OS 설치가 완료됩니다.

STEP 4. System Setup

OS 설치가 완료되면 하단의 그림과 같이 멋진 젯슨 나노용 우분투가 실행됩니다. 설치 이후 초기 설정은 이전 포스팅을 참고해주세요.

1. 젯슨 나노에 파이참 설치하기 : deep-eye.tistory.com/21

[Jetson] Jetson Nano, TX2, Xavier에 Pycharm 파이참 IDE 설치하기

Nvidia의 Jetson는 소형 임베디드 AI 시스템의 혁신적인 시리즈입니다. CUDA 프로세서와 라이브러리가 최적화되어 다양한 AI 솔루션으로 활용가능한 장점이 있습니다. 다만, 일반적인 리눅스 환경이

deep-eye.tistory.com

2. 젯슨 나노 시스템 모니터링 프로그램 설치하기 : deep-eye.tistory.com/22

[Jetson] Jetson Nano, TX2, Xavier에 시스템 모니터링 및 컨트롤 패키지 Jetson stats 설치하기

소형 임베디드 AI 시스템의 혁신적인 Jetson 시리즈는 리눅스를 기반으로 구동되지만, aarch64 아키텍터로 설계되어 일부 패키지를 이용하는데 불편한 점이 있었습니다. 제가 처음 Jetson으로 프로젝

deep-eye.tistory.com

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Matlab] 매트랩에서 개발자 코딩 폰트 설정하기 (D2 Coding)

Jinsoo Kim — Wed, 27 Jan 2021 11:25:01 +0900

개발자용 코딩 폰트 D2 Coding

이번 포스트는 매트랩에 D2 Coding 개발자 폰트를 적용하는 방법입니다. 일반적인 폰트에서 i, l, 1 등은 직관적으로 구별하기가 쉽지 않지만, 개발자용 폰트를 사용하게 되면 구분이 쉬워지며 줄간격, 글자 간격등이 일치하게 되어 깔끔해집니다.

D2 Coding 폰트는 네이버에서 개발된 폰트이며 다른 개발자용 폰트와 다르게 한글까지 호환되어 주석 작성에 편리함을 줍니다.

적용 방법

https://github.com/naver/d2codingfont에서 접속한 후 [Downloads ZIP]을 클릭하여 다운로드합니다.

다운로드한 파일의 압축을 해제한 다음에는 다운로드 위치에 접근하여 가장 최신 버전의 폰트의 압축을 해제합니다.

D2 CodingAl l폴더에 접근한 후 폰트 파일을 우클릭하여 [모든 사용자용으로 설치]를 클릭합니다.

[설치(I)]버튼을 클릭합니다.

매트랩을 실행한 후 [기본 설정]을 클릭합니다.

글꼴 설정에서 글꼴을 D2 Coding으로 설정합니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Matlab] 매트랩 화면에 개발자용 테마 적용하기

Jinsoo Kim — Wed, 27 Jan 2021 11:03:57 +0900

매트랩 코딩 테마

코딩이 이루어지는 공간은 장시간동안 집중해서 보는 공간이므로, 눈의 피로도가 낮고 가독성이 높은 글자 폰트를 사용하는것이 좋습니다. 따라서, Visual Studio나 Spyder, Pycharm 등의 IDE에서는 다양한 테마를 지원하고 있는데요. 이번 포스트는 기타 IDE과 같이 매트랩에서 테마를 적용할 수 있는 간단한 포스트입니다.

기본적인 테마를 적용하면 다음과 같이 매트랩 화면을 변경할 수 있습니다.

Cobalt

Darkmate

Matrix

적용방법

https://github.com/scottclowe/matlab-schemer에서 다운로드 받을 수 있으며 총 11개의 테마가 있습니다. 접속한 후 [Downloads ZIP]을 클릭하여 다운로드 받습니다.

다운로드 받은 파일의 압축을 풀면 다음과 같은 파일들이 존재합니다.

위의 그림과 같은 디렉토리의 경로를 복사해줍니다. 디렉토리의 경로를 복사하는 방법은 다음과 같습니다. 밑의 그림에서 빨간색 점이 있는 부분을 좌클릭합니다.

그리고 그림처럼 경로가 파란색으로 뜬 다음에 [Ctrl + C]로 복사를 해줍니다.

이제 매트랩을 실행시킨 후 복사한 경로를 붙여넣기 해줍니다.

다운로드 받은 파일의 디렉토리로 접근이 완료되면 다음과 같이 현재 폴더에서 설치된 파일들을 볼 수 있습니다.

그리고 명령창에 [schemer_import]를 입력합니다.

그러면 schemer_import파일이 실행되고 [schemes] 폴더에 진입하여 원하는 테마를 선택하시면 됩니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Darknet] Yolo 구현을 위한 darknet 설치 - yolov4

Jinsoo Kim — Wed, 27 Jan 2021 10:28:00 +0900

1. Cmake 다운로드

cmake download를 검색하여 다운로드 사이트로 이동합니다. (링크 : https://cmake.org/download/)

Download | CMake

Current development distribution Each night binaries are created as part of the testing process. Other than passing all of the tests in CMake, this version of CMake should not be expected to work in a production environment. It is being produced so that us

cmake.org

[cmake-3.17.0-rc1.tar.gz]를 다운로드합니다. 3.17 버전 이외의 최신 버전을 다운로드하셔도 상관없습니다.

그리고 다운로드한 경로로 접근하여 압축을 해제합니다.

tar -xvzf cmake-3.17.0-rc1.tar.gz

압축 해제가 완료된 후에 qt5, SSL패키지를 설치합니다.

sudo apt install qt5-default

sudo apt-get install build-essential

sudo apt install libssl-dev

다운로드한 cmake 설치 파일의 경로로 이동한 후 bootstrap파일을 실행합니다.

./bootstrap

bootstrap파일이 정상적으로 실행되면 다음 두 명령어를 차례로 입력하여 컴파일을 진행합니다.

make

sudo make install

cmake가 정상적으로 다운된 경우 다음과 같이 cmake 버전을 확인할 수 있습니다.

2. Opencv 다운로드

설치 전 패키지 업데이트 및 업그레이드를 진행합니다.

sudo apt update

sudo apt upgrade

opencv 설치를 위한 패키지를 다운로드합니다.

sudo apt-get install build-essential cmake pkg-config libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev libavcodec-dev libavformat-dev libswscale-dev libxvidcore-dev libx264-dev libxine2-dev libv4l-dev v4l-utils libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev libqt4-dev mesa-utils libgl1-mesa-dri libqt4-opengl-dev libatlas-base-dev gfortran libeigen3-dev python2.7-dev python3-dev python-numpy python3-numpy

opencv를 다운로드할 폴더를 생성합니다. 이때 폴더의 상위 경로 한글 명인 경우 나중에 오류가 발생합니다.

예를 들어, cmake 설치 파일이 다운로드된 [다운로드] 폴더에 opencv를 다운로드할 폴더를 생성하면 opencv 설정을 진행하는 경우 오류가 생깁니다. 따라서 홈 경로에 설치 폴더를 생성하는 것을 권장합니다.

mkdir opencv && cd opencv

설치 파일을 다운로드하고 압축을 해제합니다.

wget -O opencv.zip https://github.com/Itseez/opencv/archive/3.4.0.zip

unzip opencv.zip

wget -O opencv_contrib.zip https://github.com/Itseez/opencv_contrib/archive/3.4.0.zip

unzip opencv_contrib.zip

[opencv-3.4.0] 폴더에 접근한 후 [build] 폴더를 생성합니다.

cd opencv-3.4.0

mkdir build && cd build

darknet 사용 환경에 맞춰 opencv 환경을 설정합니다.

cmake -D CMAKE_BUILD_TYPE=RELEASE \
-D CMAKE_INSTALL_PREFIX=/usr/local \
-D WITH_TBB=OFF \
-D WITH_IPP=OFF \
-D WITH_1394=OFF \
-D BUILD_WITH_DEBUG_INFO=OFF \
-D BUILD_DOCS=OFF \
-D INSTALL_C_EXAMPLES=ON \
-D INSTALL_PYTHON_EXAMPLES=ON \
-D BUILD_EXAMPLES=OFF \
-D BUILD_TESTS=OFF \
-D BUILD_PERF_TESTS=OFF \
-D WITH_QT=ON \
-D WITH_OPENGL=ON \
-D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-3.4.0/modules \
-D WITH_V4L=ON \
-D WITH_FFMPEG=ON \
-D WITH_XINE=ON \
-D BUILD_NEW_PYTHON_SUPPORT=ON \
-D BUILD_opencv_xfeatures2d=OFF \
-D CMAKE_INSTALL_PREFIX=/usr/local \
-D WITH_GSTREAMER=ON -D WITH_FFMPEG=ON \
../

cmake 다운로드와 마찬가지로 다음 두 명령어를 입력하여 컴파일을 진행합니다.

make

sudo make install

pkg-config --cflags opencv

3. Nvidia 그래픽 드라이버 설치

CUDA, CUDNN의 사용을 위해 NVIDIA 그래픽 카드 드라이버 설치를 진행합니다.

[시스템 설정] - [소프트웨어 & 업데이트] - [추가 드라이버]로 진입한 후 NVIDIA 그래픽 카드를 선택하고 [바뀐 내용 적용(A)]을 클릭합니다. 설치가 완료된 후에는 재부팅을 진행합니다.

4. CUDA 설치

cuda download를 검색하여 다운로드 사이트로 이동합니다.

https://developer.nvidia.com/cuda-10.1-download-archive-base?target_os=Linux&target_arch=x86_64&target_distro=Ubuntu&target_version=1604&target_type=debnetwork

CUDA Toolkit 10.1 original Archive

Select Target Platform Click on the green buttons that describe your target platform. Only supported platforms will be shown. Operating System Architecture Distribution Version Installer Type Do you want to cross-compile? Yes No Select Host Platform Click

developer.nvidia.com

가장 최신 버전은 10.2이지만, 파이토치(Pytorch)나 텐서플로우(Tensorflow)등의 프레임워크들에서 호환되는 버전은 아직까지 10.1이기 때문에 10.1 버전으로 다운로드합니다.

[Linux] - [x86_64] - [Ubuntu] - [18.04] - [deb (network)]를 선택한 후 [Donwload] 버튼을 클릭합니다.

파일이 다운로드된 이후에는 CUDA 설치를 명령어로 진행합니다.

sudo dpkg -i cuda-repo-ubuntu1604_10.1.105-1_amd64.deb

sudo apt-key adv --fetch-keys http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/7fa2af80.pub

sudo apt update

업데이트 후 데스크탑을 재부팅한 뒤에 다시 명령어를 실행합니다.

sudo apt install cuda

만약 설치 과정에서 다음과 같은 오류가 발생하는 경우 다음 명령어로 CUDA를 설치합니다.

sudo apt install cuda --fix-missing

5. CUDNN 설치

cuda download를 검색하여 다운로드 사이트로 이동하고 [Download CUDNN]를 클릭한 후 로그인합니다.

(링크 : https://developer.nvidia.com/cudnn)

체크박스를 클릭하여 라이센스에 동의한 후 설치한 CUDA버전에 맞는 CUDNN 중에서 [cuDNN Library for LINUX]를 다운로드합니다. 다운로드한 후에는 설치 파일의 압축을 해제합니다.

tar -xvzf cudnn-10.2-linux-x64-v7.6.5.32.tgz

다음 명령어를 실행합니다.

sudo cp -P cuda/include/cudnn.h /usr/local/cuda/include

sudo cp -P cuda/lib64/libcudnn* /usr/local/cuda/lib64

sudo chmod a+r /usr/local/cuda/include/cudnn.h /usr/local/cuda/lib64/libcudnn*

설치 완료 후에는 환경변수를 설정합니다.

터미널에서 다음 명령어를 통해 쉘을 실행합니다.

nano ~/.bashrc

가장 마지막 부분에 다음과 같이 입력한 후 저장합니다.

export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64"
export CUDA_HOME=/usr/local/cuda

6. Darknet 설치

깃허브의 darknet은 pjreddie, AlexeyAB 2가지 버전이 있습니다. AlexeyAB버전의 darknet을 다운로드합니다.

(링크 : https://github.com/AlexeyAB/darknet)

git clone https://github.com/AlexeyAB/darknet.git

설치된 [darknet] 폴더로 접근한 후 [Makefile]의 설정을 수정합니다.

cd darknet

nano Makefile

cuda, cudnn, opencv를 사용하기 위해 GPU = 1, CUDNN = 1, OPENCV=1로 수정합니다.

그림처럼 [darknet] 실행파일이 생성되면 cuda, cudnn, opencv가 문제없이 설치된 것입니다.

마지막으로 darknet을 이용해서 단일 이미지에 대한 object detection을 진행해보겠습니다.

darknet 사용 방법은 다음 포스트에서 상세하게 작성할 예정입니다.

먼저 가중치 파일을 다운로드 받습니다.

wget https://pjreddie.com/media/files/yolov3.weights

그리고 단일 이미지에 대하여 객체를 탐지하는 명령어를 실행합니다.

./darknet detect cfg/yolov3.cfg yolov3.weights data/dog.jpg

명령어를 실행하면 구축되어 있는 CNN에 대해 Feed-foward가 진행되며 터미널에는 탐지된 객체의 종류, 신뢰도가 출력됩니다.

또한 Makefile의 OPENCV=1로 설정했기 때문에 탐지 결과가 이미지에 표시된 창이 생성됩니다.

Contact Us

blog : https://deep-eye.tistory.com
mail : deepi.contact.us@gmail.com

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Study With DI] 스터디 윗미 타이머 위젯 설정 방법

주식회사 딥아이 — Wed, 27 Jan 2021 00:24:20 +0900

Download Link

deep-eye.tistory.com/32

[Python] 스터디 윗미 타이머 프로그램 Study With DI

With DI ver - 1.0.0 스터디윗미 방송이나 PC 환경에서 공부하시는 분들을 위한 타이머 프로그램 위드디(with DI)입니다. 가끔 유튜브에서 코딩 방송하고 있는데 좀 더 저에게 필요한 기능만 구성하고

deep-eye.tistory.com

List

1. Study With DI 설치 방법

2. Study With DI 설정 방법

3. Study With DI 타이머 설정 방법

Study With DI 설치 방법

Study With DI 설정 방법

Study With DI 텍스트 및 위젯 타이머 설정 방법

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Matlab] 변환 행렬 (Transformation matrix)을 이용한 LIDAR 라이다 PCD 데이터 전처리 #3

주식회사 딥아이 — Mon, 25 Jan 2021 11:34:27 +0900

Concept

이번 포스팅의 주제는 라이다 데이터 전처리 기법 #3, 변환 행렬 (Transformation matrix)를 이용한 라이다 PCD 변환입니다.

지상에서 수집되는 라이다는 수집되는 장치 또는 위치에 고정된 형태로 시스템이 구축된 상태에서 가동됩니다. 설치과정에서 축을 고정하게 되어 별도의 전처리가 필요하지 않지만, 예외인 경우가 있습니다. 대표적으로 드론 탑재 시스템이 있습니다.

그림 1. 드론에 탑재된 라이다 센서 [출처: https://altigator.com/]

그림 2. 수집된 지상 3D 지도 정보 [출처: https://altigator.com/]

3차원 축을 기준으로 움직이는 드론에 탑재된 라이다의 기준 축은 필연적으로 잡음이 섞이게 됩니다. 예측 필터로 그려지는 SLAM 모델링에서는 어느정도 잡음이 억제되지만, 순간순간의 PCD 프레임은 축이 기울거나 흔들릴 수 있습니다.

이럴때 간단하게 변환 행렬 (Transformation matrix)을 통해 축 변환을 PCD에도 적용할 수 있습니다.

POST

1.라이다 데이터 전처리 [KITTI DATASET 활용하기]

2. 각도에 따라 라이다 데이터 분할하기 [Segmentation]

3. 변환 행렬을 이용하여 라이다 데이터 축 변환하기 [Transformation]
4. 복셀화를 이용한 LIDAR 라이다 PCD 데이터 압축 [Voxcelization]

Algorithm (Transformation Matrix)

그림 3. 변환행렬 적용 예시

축 변환을 위해 선형대수학 변환 행렬의 개념이 도입됩니다. 3차원 공간의 좌표축의 중심(원점)을 기준으로 θ 만큼 회전시키는 행렬은 식 1과 같습니다. 각도와 변환을 원하는 축에 따라 PCD 데이터에 행렬 곱셈을 해주면 반시계 방향으로 회전됩니다.

X축 회전 $R_{X}(\theta) =$ \begin{bmatrix} 1 & 0 & 0 \\ 0 & \cos\theta & \sin\theta \\ 0 & \sin\theta & \cos\theta \end{bmatrix}
Y축 회전 $R_{Y}(\theta) =$ \begin{bmatrix} \cos\theta & 0 & \sin\theta \\ 0 & 1 & 0 \\ -\sin\theta & 0 & \cos\theta \end{bmatrix}
Z축 회전 $R_{Z}(\theta) =$ \begin{bmatrix} \cos\theta & -\sin\theta & 0 \\ \sin\theta & \cos\theta & 0 \\ 0 & 0 & 1 \end{bmatrix}

SourceCode

1.Source Code 및 데이터 다운로드

github.com/DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

Pre-processing Technique of LIDAR PCD Data Using KITTI-Dataset - DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

github.com

git clone github.com/DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

2. 변환 행렬 함수 만들기

function output = transformation(input, angle)

x = input;
% 각도 라디안 변경
z  =deg2rad(angle);

% Transformation 행렬
u_1 = [cos(z) ; 0; -sin(z)];
u_2 = [0 ; 1 ;0];
u_3 = [sin(z) ; 0 ;  cos(z)];
P = [u_1 , u_2 , u_3];

x_p = x(:,1);
y_p = x(:,2);
z_p = x(:,3);

% 행렬 연산
new_x = (P*[x_p' ; y_p' ; z_p'])';
output= new_x;

end

저는 Y축을 기준으로 회전하기 위해 Y축 변환 행렬을 적용하였습니다. 다각도 회전을 위해서는 순차적으로 변환 행렬 곱셈을 연산하면 됩니다. 추가로 드론에서 지상 SLAM 구현을 위해 수집된 라이다 데이터 일부를 업로드했습니다. VLP16 모델이라 해상력은 낮지만 본 포스팅의 변환행렬 예시로는 좋은것같습니다.

그림 4. 변환된 PCD 데이터 (좌) 원본 (우) Y축 기준 60도 회전

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[2021-01-20] 인공지능 학습용 데이터 활용 아이디어 공모전 최우수상 수상 Prologue

주식회사 딥아이 — Thu, 21 Jan 2021 11:16:06 +0900

인공지능 학습용 데이터 활용 아이디어 공모전

안녕하세요 딥 아이입니다. 팀원과 함께 올해 새로운 비즈니스 모델 발굴을 위해 다양한 아이디어를 검토 중, 인공지능 학습용 데이터 활용 아이디어 공모전이 있다는 것을 알게 되었습니다. 전문과들과 함께 아이디어를 검증할 수도 있고 확장 가능성을 평가받기 위해 참가하게 되었습니다.

사실 작년 인공지능 문제 해결 경진대회를 참가하지 못한 것이 한이였습니다. 그래서 급하게 신청하게 됐죠...

www.aihub.or.kr/problem_contest/11364

인공지능 학습용 데이터 활용 아이디어 공모전 | AI Hub

- 운영사무국 이메일(aihubcontest@gmail.com)과 AI허브 사이트 내 [AI 경진대회] 탭 상단 ‘2020 인공지능 학습용 데이터 활용 아이디어 경진대회’의 [Q&A]란을 이용해주시길 바랍니다. - 필요한 경우, 운

www.aihub.or.kr

결선 진출 PT 이후...

정말 기대하지 않았던 1등이 되었습니다! 과학기술정보통신부 및 NIA 관계자 분들께 다시 한번 감사의 말씀드립니다. ㅎㅎ 저희는 실현 가능 서비스 부분으로 공모하였으며 요즘 관심 있어 연구 중인 GAN 신경망 기반 솔루션으로 제안하였습니다. 일정이 짧아 3일 동안 고생하며 밤낮으로 학습하고 검증하는 무한 작업을 한 보람이 있네요.

자세한 PT 내용은 모든 공모전 일정이 종료된 이후 한 번 더 정리하여 포스팅 하겠습니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] Windows에서 파이썬 아나콘다 가상 환경 만들기

주식회사 딥아이 — Wed, 13 Jan 2021 15:10:15 +0900

Concept

프로그래밍을 구현하다 보면 다양한 라이브러리, 함수, 패키지를 다운로드하게 됩니다. 이 과정이 쌓이고 쌓이다 보면 충돌이 발생하거나 특정 프로그램 구현에 필요한 패키지가 무엇인지 구분하기 어렵게 되죠. 저는 이런 문제를 방지하기 위해 모든 프로젝트마다 하나의 가상 환경을 구현하여 진행합니다. 이렇게 되면 코드가 엉키거나 의존성 문제가 발생했을때 단지 그 가상 환경만을 제거해주면 되기 때문에 편리해집니다.

이번 포스팅에서는 간단하게 아나콘다 설치부터 특정 파이썬 버전으로 가상 환경을 생성하는 방법을 다뤄보겠습니다.

1. 아나콘다 패키지 다운로드

링크를 통해 아나콘다를 설치합니다. 운용되는 환경에 맞춰 파일을 다운로드 해주세요.

www.anaconda.com/products/individual

Anaconda | Individual Edition

Anaconda's open-source Individual Edition is the easiest way to perform Python/R data science and machine learning on a single machine.

www.anaconda.com

그림 1. 아나콘다 홈페이지 (다운로드 클릭)

그림 2. 운영환경에 맞는 아나콘다 설치

1. 아나콘다 설치

생각보다 용량이 크기 때문에 시간이 소요됩니다. 다운로드가 완료되었다면 이제 설치를 시작합니다. 설치 옵션은 수정하지 않고 그대로 진행해줍니다.

그림 3. 아나콘다 설치

2. 아나콘다 콘솔창 실행

설치가 완료되면 탐색 창을 열어 Anaconda Prompt (Anaconda3)를 실행해봅니다.

그림 4. 아나콘다 실행

현재 구축된 가상 환경을 검색하는 명령어를 입력해줍니다. 아직 별도의 가상환경을 생성하지 않았기 때문에 base 환경만 리스트에 나오게 됩니다. 콘솔 창에서 복사+불어넣기는 shift + ins 키를 눌러주거나 마우스 우클릭입니다.

conda env list

그림 5. 가상환경 리스트

3. 가상 환경 생성

원하는 파이썬 버전에 맞는 가상 환경 생성 명령어입니다. 보통 파이썬 3.8을 기준으로 생성하게되면 저는 가상환경 이름은 py38 정도로 나중에 찾기 쉽게 이름을 짓습니다. 명령어를 실행하면 기타 필수 패키지 설치 문구가 나옵니다. y + 엔터를 입력해 가상환경을 생성해줍니다.

conda create -n "가상환경이름" python==x.x

그림 6. 가상환경 생성

4. 가상환경 활성화

모든 설치가 완료되면 활성화 명령어로 가상 환경에 접근합니다. python을 입력해서 정상적으로 python 버전이 맞게 실행되는지 확인합니다. 오류없이 실행되었다면 기본적인 가상환경 구축은 모두 완료됩니다.

가상환경 활성화

activate "가상환경이름"

가상환경 비활성화

deactivate

그림 7. 가상환경 활성화

5. 코딩 기본 환경 구축 (Spyder 설치)

이제 코딩을 시작할 차례입니다. 저는 spyder IDE을 주로 사용하고 있습니다. spyder 설치는 콘다에서 지원하는 conda명령어로 설치해줍니다. 의존성 설치 파일이 조금 많다 보니 약간의 시간이 소요됩니다. 모든 설치가 완료되면 이제 간단하게 spyder 명령어를 통해 IDE를 불러올 수 있습니다.

conda install spyder

그림 8. 코딩 시작

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] PDF 파일 병합 프로그램 PDF DI

주식회사 딥아이 — Tue, 12 Jan 2021 00:25:33 +0900

PDF DI ver 0.2.1

연말 연초이다 보니 진행 중인 사업의 성과 보고나 재무 회계 관련 업무가 증가하고 있습니다. 전산화로 서류 정리 업무가 줄었다고는 하지만 모든 자료가 폴더에서 나뒹구니 더 골치 아프기도 합니다.

그동안 문서 통합을 위해 PDF, 한글, 워드 파일 변환이나 편집은 무료로 변환해주는 웹을 사용했지만 번거로운 작업으로 느껴져 필요 기능만 모은 PDF 병합 프로그램을 만들게 되었습니다. 모두가 쉽게 만들 수 있는 파이썬 PyPDF2 라이브러리를 기반으로 하였으며 업데이트를 통해 한글 파일이나 그림 파일도 통합하여 변환할 수 있도록 발전시킬 예정입니다.

핵심 기능

PDF 파일 병합 기능
JPG, PNG 그림 파일 자동 병합
PDF 파일 페이지 자르기 (추가 예정)
한글, 워드 파일 자동 병합 (추가 예정)

사용법 (PDF 병합하기)

배포판 프로그램 링크를 통해 다운로드한 뒤, 압축 해제해주세요.
PDFDI 프로그램을 실행해주세요.
개인 배포 프로그램이기에 백신 경고가 발생합니다. 무시한 뒤, 관리자 권한으로 실행해주면 됩니다.
파일 추가 버튼을 통해 병합을 원하는 PDF 파일을 추가해줍니다.
병합 순서는 위아래 버튼으로 변경할 수 있습니다.
병합하기를 클릭 후 저장 파일 경로와 이름을 지정해주면 병합이 완료됩니다.

다운로드

소스 코드 (Python 3.8 + PyQt5 + PyPDF2): github.com/DEEPI-LAB/python-pdf-merger-PDFDI

DEEPI-LAB/python-pdf-merger-PDFDI

Contribute to DEEPI-LAB/python-pdf-merger-PDFDI development by creating an account on GitHub.

github.com

git clone https://github.com/DEEPI-LAB/python-pdf-merger-PDFDI

배포판 (Windows 10/7 35mb): drive.google.com/file/d/1TEW-UMLeLre2q71t5Gpn1LRiNLj_7jhk/view?usp=sharing

PDFDI_0.2.1.zip

drive.google.com

패치노트

깃허브 링크 참조 : github.com/DEEPI-LAB/python-pdf-merger-PDFDI

[2021-01-14] - VER 0.2.0

- JPG, PNG 병합 기능 추가

- 권한 충돌로 인한 병합 오류 수정

- UI 개선

[2021-01-24] - VER 0.2.1

- JPG, PNG 병합 오류 수정

- UI 개선

Contact Us

사용방법 및 오류 관련 문의는 댓글 남겨주세요.

맞춤 제작이나 기능 관련 문의는 메일 주세요.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Matlab] 이미지로 동영상 만들기 및 동영상의 프레임을 이미지로 저장하기

Jinsoo Kim — Mon, 11 Jan 2021 16:31:24 +0900

Concept

일반적으로 YOLO, SSD, Faster R-CNN 등의 CNN 기반의 객체 탐지 알고리즘을 다루는 경우에는 단일 이미지로 학습을 진행하게 됩니다. 모델 최적화를 통해 학습을 완료한 후 AP(Average Precision)를 측정하는 과정을 통해 학습을 마무리하는데 테스트 과정에서 객체 탐지 모델의 성능을 시각화하는 경우 이미지를 동영상으로 변환해야 하는 상황이 생깁니다. 그리고 학습에 사용할 데이터셋을 구축하기 위해 동영상의 프레임에서 이미지를 추출하기도 합니다.

이번 포스트는 위와 같은 상황에서 이미지를 비디오로, 비디오를 이미지로 변환해주는 매트랩 소스 코드입니다.

자율주행 벤치마킹 데이터셋 KITTI를 활용하여 간단하게 소스 코드를 작성해보겠습니다.

1. 이미지를 비디오로 변환

이미지를 비디오로 변환하는 소스 코드는 일반적인 파일 입출력 코드와 유사합니다.

dList_img = dir(strcat('이미지가 저장된 디렉토리', '*.png'));

먼저 '이미지가 저장된 디렉토리'를 설정하여 해당 폴더의 특정 확장자(png)의 파일들을 읽어 디렉토리 변수를 설정합니다. 이미지들의 파일명은 프레임 순서에 따라 정렬되어있어야 합니다.

그리고 불러온 이미지로 생성할 '비디오를 저장할 디렉토리 + 파일명'과 프레임레이트를 설정합니다. 예를 들어 D드라이브에 movie라는 이름으로 비디오를 저장한다면 소스 코드는 vid = VideoWriter('D:/movie.avi')가 됩니다.

그리고 프레임레이트가 높을수록 동영상의 속도가 빨라집니다.

vid = VideoWriter('비디오를 저장할 디렉토리 + 파일명');
vid.FrameRate = 10;

마지막으로 비디오를 저장하기 위해 파일을 열고 이미지 디렉토리 변수에서 이미지들을 불러옵니다. 이미지들은 비디오 파일에 작성되며 쓰기가 완료된 후에는 파일을 닫아줍니다.

open(vid) 
for i = 1 : length(dList_img) 
    img = imread(strcat('이미지가 저장된 디렉토리', dList_img(i).name)); 
    writeVideo(vid, img); 
end 
close(vid)

최종코드

dList_img = dir(strcat('이미지가 저장된 디렉토리', '*.png')); 
vid = VideoWriter('비디오를 저장할 디렉토리 + 파일명');
vid.FrameRate = 10;

open(vid) 
for i = 1 : length(dList_img) 
    img = imread(strcat('이미지가 저장된 디렉토리', dList_img(i).name)); 
    writeVideo(vid, img); 
end 
close(vid)

2. 비디오를 이미지로 변환

이미지를 비디오로 변환하는 소스 코드는 1번의 과정을 반대로 진행합니다.

vid = VideoReader('비디오가 저장된 디렉토리 + 파일명');
numFrames = vid.NumberOfFrames;

먼저 비디오를 불러온 후에 프레임 개수를 카운팅합니다.

for t = 1 : numFrames 
    img = read(vid, t);  
    imwrite(img, strcat('이미지를 저장할 디렉토리', sprintf('%03d', t), '.png')); 
end

그리고 for문을 사용해서 모든 프레임을 이미지 저장경로에 하나씩 저장합니다.

최종코드

clear all 
vid = VideoReader('비디오가 저장된 디렉토리 + 파일명');
numFrames = vid.NumberOfFrames; 

for t = 1 : numFrames 
    img = read(vid, t);  
    imwrite(img, strcat('이미지를 저장할 디렉토리', sprintf('%03d', t), '.png')); 
end

Contact Us

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] 파이썬 OpenCV를 이용한 성별 및 나이 예측하기

주식회사 딥아이 — Wed, 6 Jan 2021 17:29:29 +0900

Concept

지난 포스팅에 이어, 얼굴 인식 후 적용할 수 있는 성별 및 나이 예측 알고리즘입니다. 모두 파이썬 기반 OpenCV를 통해 구현하였으며 지난 포스팅을 참고하시면 기본적인 얼굴 탐지 알고리즘을 구현할 수 있습니다.

deep-eye.tistory.com/18

[Python] 파이썬 OpenCV를 이용한 얼굴 인식

과거 얼굴인식은 첩보영화나 CSI와 같은 드라마에서 범죄자를 찾는데 활용되는 신기술로 인식되었으나, 머신러닝과 하드웨어의 발전으로 이젠 일상에서 쉽게 접할 수 있게 되었습니다. 현재 얼

deep-eye.tistory.com

Algorithm

비교적 단순한 구조를 가지는 CNN 기반 신경망 모델입니다. 얼굴 탐지를 통해 예측된 얼굴의 위치 (경계 상자)를 기준으로 이미지를 추출한 뒤, 성별 또는 연령 데이터에 학습된 분류기에 입력하는 방식입니다.

MNIST나 강아지 고양이 분류 모델과 구조적으로 동일하며 그림 1과 같이 입력 영상과 출력 클래스가 다를 뿐이죠.

그림 1. Gender Recognition Through Face Using Deep Learning (ICCIDS 2018)

SourceCode

전체 코드는 깃허브를 통해 공유하고 있습니다. 링크를 참조해주세요.

github.com/DEEPI-LAB/python-opencv-face-detector.git

DEEPI-LAB/python-opencv-face-detector

Contribute to DEEPI-LAB/python-opencv-face-detector development by creating an account on GitHub.

github.com

git clone https://github.com/DEEPI-LAB/python-opencv-face-detector.git

구글 드라이브 링크를 통해 학습된 가중치를 다운받으세요. 얼굴 탐지기, 성별 분류기, 연령 분류기 학습 가중치이며 90mb 정도 됩니다. 이후 코드가 작성될 경로로 복사해주시면 됩니다.

1. 사전학습된 가중치 파일 불러오기

MODEL_MEAN_VALUES = (78.4263377603, 87.7689143744, 114.895847746)

# 언령 예측 모델 불러오기
age_net = cv2.dnn.readNetFromCaffe(
	'deploy_age.prototxt',
	'age_net.caffemodel')

# 성별 예측 모델 불러오기
gender_net = cv2.dnn.readNetFromCaffe(
	'deploy_gender.prototxt',
	'gender_net.caffemodel')

# 연령 클래스
age_list = ['(0 ~ 2)','(4 ~ 6)','(8 ~ 12)','(15 ~ 20)',
            '(25 ~ 32)','(38 ~ 43)','(48 ~ 53)','(60 ~ 100)']
# 성별 클래스
gender_list = ['Male', 'Female']

readNetFromCaffe 함수로 연령과 성별 예측 모델을 불러옵니다. 학습된 클래스는 age_list와 gender_list로 표현됩니다. 연령의 경우 분포도가 조금 신기합니다. 20세 이하 클래스에 대해선 분포도가 촘촘하네요.

만약 최종적으로 예측된 age_net의 결과가 1, gender_net의 결과가 0이라면 성별은 남자, 연령은 4 ~ 6세로 예측된 겁니다.

2. 인식된 얼굴을 기준으로 성별 및 연령 예측하기

for box in results:

    # 예측된 얼굴의 위치
    x, y, w, h = box
    # 얼굴 이미지 추출
    face = img[int(y):int(y+h),int(x):int(x+h)].copy()
    # 성별 및 연령 예측을 위한 이미지 변환 맟 전처리
    blob = cv2.dnn.blobFromImage(face, 1, (227, 227), MODEL_MEAN_VALUES, swapRB=False)
    
    # gender detection
    gender_net.setInput(blob)
    gender_preds = gender_net.forward()
    # 가장 높은 Score값을 선정
    gender = gender_preds.argmax()
    # Predict age
    age_net.setInput(blob)
    age_preds = age_net.forward()
    # 가장 높은 Score값을 선정
    age = age_preds.argmax()
    
    info = gender_list[gender] +' '+ age_list[age]

    cv2.rectangle(img, (x,y), (x+w, y+h), (255,255,255), thickness=2)
    cv2.putText(img,info,(x,y-10),0, 0.5, (0, 255, 0), 1)

인식된 얼굴을 기준으로 성별과 연령 예측 모델을 입력한 뒤, cv2.putText()로 예측된 정보를 경계 상자 테두리에 입력해줍니다.

3. 전체 소스코드

# -*- coding: utf-8 -*-
"""
Created on Wed Nov 4 
@author: jongwon Kim 
         Deep.I Inc.
"""

import cv2

# 영상 검출기
def videoDetector(cam,cascade,age_net,gender_net,MODEL_MEAN_VALUES,age_list,gender_list):

    while True:

        # 캡처 이미지 불러오기
        ret,img = cam.read()
        # 영상 압축
        try:
            img = cv2.resize(img,dsize=None,fx=1.0,fy=1.0)
        except: break
        # 그레이 스케일 변환
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) 
        # cascade 얼굴 탐지 알고리즘 
        results = cascade.detectMultiScale(gray,            # 입력 이미지
                                           scaleFactor= 1.1,# 이미지 피라미드 스케일 factor
                                           minNeighbors=5,  # 인접 객체 최소 거리 픽셀
                                           minSize=(20,20)  # 탐지 객체 최소 크기
                                           )

        for box in results:
            x, y, w, h = box
            face = img[int(y):int(y+h),int(x):int(x+h)].copy()
            blob = cv2.dnn.blobFromImage(face, 1, (227, 227), MODEL_MEAN_VALUES, swapRB=False)

            # gender detection
            gender_net.setInput(blob)
            gender_preds = gender_net.forward()
            gender = gender_preds.argmax()
            # Predict age
            age_net.setInput(blob)
            age_preds = age_net.forward()
            age = age_preds.argmax()
            
            info = gender_list[gender] +' '+ age_list[age]

            cv2.rectangle(img, (x,y), (x+w, y+h), (255,255,255), thickness=2)
            cv2.putText(img,info,(x,y-15),0, 0.5, (0, 255, 0), 1)


         # 영상 출력
        cv2.imshow('facenet',img)

        if cv2.waitKey(1) > 0: 

            break

# 사진 검출기
def imgDetector(img,cascade,age_net,gender_net,MODEL_MEAN_VALUES,age_list,gender_list):
    
    # 영상 압축
    img = cv2.resize(img,dsize=None,fx=1.0,fy=1.0)
    # 그레이 스케일 변환
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) 
    # cascade 얼굴 탐지 알고리즘 
    results = cascade.detectMultiScale(gray,            # 입력 이미지
                                       scaleFactor= 1.5,# 이미지 피라미드 스케일 factor
                                       minNeighbors=5,  # 인접 객체 최소 거리 픽셀
                                       minSize=(20,20)  # 탐지 객체 최소 크기
                                       )        

    for box in results:

        x, y, w, h = box
        face = img[int(y):int(y+h),int(x):int(x+h)].copy()
        blob = cv2.dnn.blobFromImage(face, 1, (227, 227), MODEL_MEAN_VALUES, swapRB=False)
        
        # gender detection
        gender_net.setInput(blob)
        gender_preds = gender_net.forward()
        gender = gender_preds.argmax()
        # Predict age
        age_net.setInput(blob)
        age_preds = age_net.forward()
        age = age_preds.argmax()
        info = gender_list[gender] +' '+ age_list[age]
        cv2.rectangle(img, (x,y), (x+w, y+h), (255,255,255), thickness=2)
        cv2.putText(img,info,(x,y-15),0, 0.5, (0, 255, 0), 1)

    # 사진 출력
    cv2.imshow('facenet',img)  
    cv2.waitKey(10000)

# 얼굴 탐지 모델 가중치
cascade_filename = 'haarcascade_frontalface_alt.xml'
# 모델 불러오기
cascade = cv2.CascadeClassifier(cascade_filename)


MODEL_MEAN_VALUES = (78.4263377603, 87.7689143744, 114.895847746)

age_net = cv2.dnn.readNetFromCaffe(
	'deploy_age.prototxt',
	'age_net.caffemodel')

gender_net = cv2.dnn.readNetFromCaffe(
	'deploy_gender.prototxt',
	'gender_net.caffemodel')

age_list = ['(0 ~ 2)','(4 ~ 6)','(8 ~ 12)','(15 ~ 20)',
            '(25 ~ 32)','(38 ~ 43)','(48 ~ 53)','(60 ~ 100)']
gender_list = ['Male', 'Female']

# 영상 파일 
cam = cv2.VideoCapture('sample.mp4')
# 이미지 파일
img = cv2.imread('sample.jpg')

# 영상 탐지기
videoDetector(cam,cascade,age_net,gender_net,MODEL_MEAN_VALUES,age_list,gender_list )
# 사진 탐지기
# imgDetector(img,cascade,age_net,gender_net,MODEL_MEAN_VALUES,age_list,gender_list )

그림 2. 성별 및 연령 예측 결과

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Matlab] 극좌표계를 이용한 LIDAR 라이다 PCD 데이터 Segmentation #2

주식회사 딥아이 — Mon, 4 Jan 2021 21:22:39 +0900

Concept

지난 포스팅에 이은 라이다 데이터 전처리 기법 #2, PCD Segmentation 알고리즘입니다.

일반적인 라이다는 360도 전 구간에서 데이터를 수집합니다. 모든 데이터가 필요하기도 하지만, 측면이나 후면에 부착된 도로 주행 분석 시스템에서는 불필요 데이터를 제거해야 합니다. 이를 위해 방사되는 각도에 따른 분할 알고리즘을 구현해보도록 하겠습니다.

그림 1. PCD 데이터 시각화

POST

1.라이다 데이터 전처리 [KITTI DATASET 활용하기]

2. 각도에 따라 라이다 데이터 분할하기 [Segmentation]

3. 변환 행렬을 이용하여 라이다 데이터 축 변환하기 [Transformation]
4. 복셀화를 이용한 LIDAR 라이다 PCD 데이터 압축 [Voxcelization]

Algorithm (Polar Coordinates)

분할을 위해 극좌표계 (polar coordinate system)의 개념이 도입됩니다. 극좌표계는 평면 위의 위치를 각도와 거리를 써서 나타내는 좌표계입니다. X, Y로 표현되는 직교 좌표계에서는 삼각함수로 복잡하게 나타나는 관계가 간단하게 표현되기에 PCD 데이터 전처리에도 유용하게 사용됩니다.

PCD는 3차원 데이터지만 라이다 PCD가 센서(원점)로부터 방사되는 형태이기 때문에 반지름 성분과 각 성분으로 결정할 수 있습니다. 반지름은 원점으로부터 거리를 나타내며 각 성분은 X축 또는 Y축을 기반으로 반시계 방향으로 잰 각의 크기를 나타냅니다.

반지름 $ r = \sqrt{x^2 + y^2)} $

각도 $ \theta = tan^{-1} (y / x) $

위 수식을 통해 극좌표계로 쉽게 변환되며, 그림 2와 같이 Z 축은 고정하고 변환을 해주면 됩니다.

그림 2. PCD 데이터 좌표계 변환

SourceCode

1. SorceCode 및 데이터 다운로드

github.com/DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

Pre-processing Technique of LIDAR PCD Data Using KITTI-Dataset - DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

github.com

git clone github.com/DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

2. X, Y, Z 축을 기준으로 임계값 제거

그림 1과 같이 라이다 센서는 이론적으로 100m 이상 센싱할 수 있습니다. 하지만 방사되는 빛의 특성으로 무의미한 값들이 많이 분포하게 됩니다. 데이터를 정규화하고 기준값을 지정하기 위해 우선, 좌표값을 기준으로 데이터를 추출합니다.

하단의 코드는 PCD 정규화를 위해 추출되는 영역을 지정하는 함수입니다.

function xyzi = ROIextraction(xyzi,x,y,z,flag)

if (flag == 'height')
    
    xyzi = xyzi(xyzi(:,1) > x(1) & xyzi(:,1) < x(2) & xyzi(:,2) > y(1) & xyzi(:,2) < y(2),:);
    xyzi = xyzi(xyzi(:,3) > z(1) & xyzi(:,3) < z(2),:);
    
elseif (flag == 'intensity')
    
    xyzi = xyzi(xyzi(:,1) > x(1) & xyzi(:,1) < x(2) & xyzi(:,2) > y(1) & xyzi(:,2) < y(2),:);
    xyzi = xyzi(xyzi(:,4) > z(1) & xyzi(:,4) < z(2),:);

else
    error('No matching values found');
end

X축 기준 -30 ~ 30, Y축 기준 -30 ~ 30, Z축 기준 -2 ~ 5m로 PCD를 추출합니다. KITTI 데이터는 차량에서 수집되어 원점이 지상에서 2m가량 높기 때문에 -2 이하 데이터를 제거했습니다. 정규화 이후, 이전 포스팅에서 구현한 시각화 함수를 적용하면 그림 3과 같이 지정된 영역 내 데이터로 추출된 PCD를 확인할 수 있습니다.

% 2nd preprocessing
xyzi = ROIextraction(xyzi,[-30,30],[-30,30],[-2,5],'height'); 

%2D scatter
visualization2D(xyzi)

그림 3. 임계값을 기준으로 추출된 PCD

3. 극좌표계 변환

section 값은 분할된 각도 영역의 크기를 나타냅니다. 예를 들어 30으로 지정하면, 360 / 30 = 12개의 영역으로 분할 됩니다. atan2 함수를 통해 극좌표계의 각도 값을 추출한 뒤, 이를 PCD의 인덱스 idx로 할당합니다.

반환되는 값은 PCD 모든 점 데이터에 대응하는 각도값 인덱스가 되며 gscatter 함수로 시각화하면 그림 4와 같습니다.

function idx = segmentation(xyzi,section)

alpha = section; 
num = 180/alpha;
num = -num : 1 : num ;
idx = zeros(size(xyzi,1),1);
seg= rad2deg(atan2(xyzi(:,1),xyzi(:,2))) / alpha;

for i = 1 : 360/alpha
    
    temp_1 = num(i);
    temp_2 = num(i+1);
    idx(find(seg >= temp_1 & seg < temp_2)) = i;
    
end
end

그림 4. 각도에 따라 분할된 PCD 영역

추출을 원하는 인덱스를 기준으로 PCD를 정리하면 그림 5와 같이 관심 영역을 설정할 수 있습니다.

roi = xyzi(aidx == 2,:);
gt = xyzi(aidx ~= 2,:);
scatter(roi (:,1),roi (:,2),'.r');
hold on
scatter(gt (:,1),gt  (:,2),'.k');

그림 5. 최종 Segmentation 결과 시각화

Reference

Fast segmentation of 3D point clouds for ground vehicles (2010, June)
On the Segmentation of 3D Lidar Point Clouds

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] PyQt5를 이용한 GUI 환경 구축하기 #1 QMainWindow 실행

주식회사 딥아이 — Thu, 31 Dec 2020 13:47:47 +0900

1. Concept

파이썬의 GUI 라이브러리 중 하나인 PyQt를 이용한 GUI 프로그램 구현입니다. QT-Designer를 통해 UI를 만든 다음 Python 코드로 쉽게 연동해보도록 하겠습니다.

2. SourceCode

1. 가상 환경 구축 및 Spyder 설치

# 가상환경 생성 [python 3.8버전]
conda create -n py38_qt python==3.8

# 가상환경 실행
activate py38_qt

# Spyder + QT 설치
conda install spyder

Spyder를 설치하면 GUI 구현을 위한 의존성 패키지가 함께 설치되므로 편리합니다. 설치가 완료되면 콘솔 창에 designer를 입력 후 엔터를 눌러 qt-designer를 실행합니다.

2. Qt-Designer를 이용한 Simple UI 제작

그림 1. 초기화면

Qt-Designer의 초기화면에서 Main Window를 클릭해주면 기본적인 UI 제작을 위한 Form이 생성됩니다. 생성된 Form에는 메뉴바와 상태바가 포함되어 있습니다. 아직은 불필요하니 우클릭 또는 우측의 객체 탐색기에서 해상 객체를 삭제해줍니다.

그림 2. statusbar 삭제

그림 3. menubar 삭제

간단한 타이머 구현을 위해 좌측에 있는 위젯 상자에서 LCD Number 위젯을 클릭 후, 작성 중인 Form에 드레그 해줍니다. 위치와 크기는 지정된 이후에도 마우스나 우측의 속성 값을 통해 수정할 수 있습니다. 현재 위치가 애매하므로 레이아웃 설정을 통해 전체 form에 맞게 반응형으로 변경해줍니다.

익숙해지기 위해 다양한 위젯이나 레이아웃 등을 추가하면서 연습하시는 것도 좋습니다. 모든 작업이 완료되었다면 Python 연동을 위해 코드를 작성중인 경로에 배치가 완료된 Form을 저장해줍니다.

그림 4. Form에 추가된 위젯

그림 5. 우클릭 후 배치를 지정해준다.

3. Python GUI 코드 작성

# -*- coding: utf-8 -*-
"""
@author: Deep.I Inc. @Jongwon Kim
Revision date: 2020-12-30
See here for more information :
    https://deep-eye.tistory.com
    https://deep-i.net
"""

import sys
from PyQt5 import uic
from PyQt5.QtWidgets import QMainWindow,QApplication

# Designer로 만든 UI 경로지정
FROM_CLASS = uic.loadUiType("ui.ui")[0]

# GUI CLASS 생성
class Windows(QMainWindow,FROM_CLASS):

    def __init__(self):
        super().__init__()

        # UI 설정
        self.setupUi(self) 
        self.show()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    ShowApp = Windows()
    sys.exit(app.exec_())

파이썬에서 UI를 작성할 수도 있지만, 프로그램이 난잡해 지기 때문에 저는 Designer를 통해 [UI 파일 제작 <-> 파이썬 코드로 백엔드 작업] 의 프로세스를 선호하고 있습니다.

3. Application

deep-eye.tistory.com/43

[PyQt] 제목 표시줄 없는 Widget을 마우스로 이동시키기

1. Concept PyQt로 UI를 구성하다 보면 제목 표시줄 (Title Header)가 없는 위젯을 만드는 경우가 있습니다. 이때 생성된 위젯은 제목 표시줄이 없다면 일반적으로 이동이나 크기 변경이 불가능합니다. [m

deep-eye.tistory.com

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[PyQt] 제목 표시줄 없는 Widget을 마우스로 이동시키기

주식회사 딥아이 — Wed, 30 Dec 2020 17:53:38 +0900

1. Concept

PyQt로 UI를 구성하다 보면 제목 표시줄 (Title Header)가 없는 위젯을 만드는 경우가 있습니다. 이때 생성된 위젯은 제목 표시줄이 없다면 일반적으로 이동이나 크기 변경이 불가능합니다.

[mousePressEvent - mouseMoveEvent - mouseReleaseEvent] 통해 위젯 내 오브젝트에서 마우스로 이동하기 위한 예제입니다. 지난 포스팅에서 다룬 그림판 GUI의 변형입니다.

deep-eye.tistory.com/13?category=442845

[Python] PyQt를 이용하여 마우스로 직선 그리기

PyQt5를 이용한 마우스로 직선 그리기 python의 PyQt을 이용하여 일반적인 그림판과 같이 다양한 도형체를 그릴수 있습니다. 이러한 작업이 프로그램에 녹아들어 유저 인터페이스와 연결되기 위해

deep-eye.tistory.com

2. SourceCode

    # Drag Event Method
    
    def mousePressEvent(self, event):
        if event.button() == QtCore.Qt.LeftButton:
            self.offset = event.pos()
        else:
            super().mousePressEvent(event)

    def mouseMoveEvent(self, event):
        if self.offset is not None and event.buttons() == QtCore.Qt.LeftButton:
            self.move(self.pos() + event.pos() - self.offset)
        else:
            super().mouseMoveEvent(event)

    def mouseReleaseEvent(self, event):
        self.offset = None
        super().mouseReleaseEvent(event)

Press - Move - Release로 구성된 매서드이며, 상황에 따라 LeftButton / RightButton 또는 mouseWheelEevent로 변경할 수 있습니다. 단순하지만 이런 기능 하나하나가 앤드 유저의 편리성을 극대화시켜줍니다.

3. Application

github.com/DEEPI-LAB/python-PyQt5-Tutorials.git

DEEPI-LAB/python-PyQt5-Tutorials

Contribute to DEEPI-LAB/python-PyQt5-Tutorials development by creating an account on GitHub.

github.com

git clone https://github.com/DEEPI-LAB/python-PyQt5-Tutorials.git

# -*- coding: utf-8 -*-
"""
@author: Deep.I Inc. @Jongwon Kim
Revision date: 2020-12-30
See here for more information :
    https://deep-eye.tistory.com
    https://deep-i.net
"""

import sys
from PyQt5 import uic
from PyQt5.QtWidgets import QMainWindow,QApplication
from PyQt5.QtCore import QTimer
from PyQt5 import QtCore

FROM_CLASS = uic.loadUiType("ui.ui")[0]

class Windows(QMainWindow,FROM_CLASS):

    def __init__(self):
        super().__init__()

        # setup user interface
        self.setupUi(self) 
        # Widget Setup
        self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
        self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
        self.show()
        # Timer Application
        self.time = 0
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.Timer)
        self.timer.start(1000)

    # Timer
    def Timer(self):
        self.time += 1
        self.lcdNumber.display(self.time)
    # Drag Event Method
    def mousePressEvent(self, event):
        if event.button() == QtCore.Qt.LeftButton:
            self.offset = event.pos()
        else:
            super().mousePressEvent(event)

    def mouseMoveEvent(self, event):
        if self.offset is not None and event.buttons() == QtCore.Qt.LeftButton:
            self.move(self.pos() + event.pos() - self.offset)
        else:
            super().mouseMoveEvent(event)

    def mouseReleaseEvent(self, event):
        self.offset = None
        super().mouseReleaseEvent(event)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    ShowApp = Windows()
    sys.exit(app.exec_())

4. Reference

stackoverflow.com/questions/58901806/how-to-make-my-title-less-window-drag-able-in-pyqt5

How to make my title less Window drag-able in PyQt5?

I want to build a window which has no title bar, so i do. But it is not any more draggable. You cannot make my window move from here to there. I know it is because of me, removing the title bar, ...

stackoverflow.com

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Tensorflow] keras를 이용한 MNIST, CIFAR 이미지 분류 데이터셋 다운로드

주식회사 딥아이 — Wed, 30 Dec 2020 11:30:19 +0900

이미지 분류 알고리즘 평가에 활용되는 기본적인 데이터셋은 용량이 크지 않아 그때그때 코드로 불러 활용하기 편합니다. 텐서 플로우나 Keras가 설치되어있다면 쉽게 작업 환경으로 불러올 수 있습니다.

텐서 플로우 설치는 이전 포스팅을 참고하시면 됩니다.

deep-eye.tistory.com/7

[Tensorflow] 아나콘다 가상환경에서 텐서플로우 설치하기

deep-eye.tistory.com

Keras에 포함된 이미지 데이터 다운로드 코드

import tensorflow as tf

# Download the mnist dataset
data_train, data_test = tf.keras.datasets.mnist.load_data()

# Download the mnist fashion dataset
data_train, data_test = tf.keras.datasets.fashion_mnist.load_data()

# Download the CIFAR-10 dataset
data_train, data_test  = tf.keras.datasets.cifar10.load_data()

# Download the CIFAR-100 dataset
data_train, data_test  = tf.keras.datasets.cifar100.load_data()

MNIST 손글씨 인식 데이터

10가지 패션 범주에 대한 60,000개의 28x28 그레일 스케일 이미지로 이루어진 데이터셋과, 그에 더해 10,000개의 이미지로 이루어진 테스트셋.

MNIST-Fasion 데이터

10가지 숫자에 대한 60,000개의 28x28 그레이 스케일 이미지 데이터셋과, 그에 더해 10,000개의 이미지로 이루어진 테스트셋.

CIFAR-10 소형 이미지 분류 데이터

50,000개의 32x32 컬러 학습 이미지, 10개 범주의 라벨, 10,000개의 테스트 이미지로 구성된 데이터셋.

CIFAR-100 소형 이미지 분류 데이터

50,000개의 32x32 컬러 학습 이미지, 100개 범주의 라벨, 10,000개의 테스트 이미지로 구성된 데이터셋. CIFAR-10의 이미지에서 클래스의 SUB CLASS 범주가 확장된 형태의 데이터셋.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Tensorflow] VGG16 모델을 이용하여 CNN 이미지 분류기 학습하기

주식회사 딥아이 — Sun, 27 Dec 2020 12:44:20 +0900

1. Concept

지난 포스팅에 이어, 이번 포스팅에서는 특정한 객체를 집중적으로 분류하기 위해 사전 학습된 신경망 모델을 기반으로 가장 기초적인 방법을 통해 미세 학습 (Find-Tuning)을 구현해 보록 하겠습니다.

ImageNet으로 학습된 VGG16 모델을 기반으로, Kaggle에서 제공되는 고양이 강아지 분류 데이터를 활용하겠습니다. 데이터는 200mb 정도이며 Kaggle 원문 링크 또는 구글 드라이브에서 받으실 수 있습니다.

그림 1. Cat and Dog 분류를 위한 신경망 모델 (원문 링크 글 하단 참조)

구현 환경 : Windows 10 / Conda / Python 3.8 / Tensorflow 2.2 / CUDA 10.2

이전 포스팅을 참고하시면 기초적인 텐서플로우 구현에 도움이 됩니다

2. Python Code

1. 소스코드 다운로드 : github.com/DEEPI-LAB/python-TensorFlow-Tutorials.git

DEEPI-LAB/python-TensorFlow-Tutorials

Contribute to DEEPI-LAB/python-TensorFlow-Tutorials development by creating an account on GitHub.

github.com

git clone https://github.com/DEEPI-LAB/python-TensorFlow-Tutorials.git

2. 사전학습된 VGG16 모델 불러오기

from tensorflow.python.keras.applications.vgg16 import VGG16
from tensorflow.python.keras.preprocessing.image import ImageDataGenerator
from tensorflow.python.keras.layers import Conv2D, MaxPooling2D, Flatten,
from tensorflow.python.keras.layers import Dense, Dropout, Input
from tensorflow.python.keras.models import Model

# 사전 학습된 모델 불러오기
input_tensor = Input(shape=(150,150,3))
model = VGG16(weights='imagenet', include_top=False, input_tensor = input_tensor)

VGG16 MODEL 함수

사전 학습된 VGG16 모델을 불러옵니다. Find-Tuning으로 새로운 분류기를 학습하기 위해 기존의 FC (Fully-Connected Layer)를 제거하고 입력되는 이미지의 크기 input_tensor를 지정합니다.

input_tensor는 사용되는 분류기 특성이나 학습 이미지의 크기 등을 고려하여 설정하면 됩니다. 하지만 include_top이 True일 경우, 입력 이미지의 크기는 사전 학습된 모델과 같이 224x224x3으로 고정되기 때문에 input_tensor로 변경할 수 없습니다.

3. VGG 신경망 모델 디자인

# 모델 Layer 데이터화
layer_dict = dict([(layer.name, layer) for layer in model.layers])

# Layer 추가
x = layer_dict['block5_pool'].output
# Cov2D Layer +
x = Conv2D(filters = 64, kernel_size=(3, 3), activation='relu')(x)
# MaxPooling2D Layer +
x = MaxPooling2D(pool_size=(2, 2))(x)
# Flatten Layer +
x = Flatten()(x)
# FC Layer +
x = Dense(2048, activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(1024, activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(2, activation='softmax')(x)

# new model 정의
new_model = Model(inputs = model.input, outputs = x)

신경망 기본 Layer 함수

기본적인 신경망 모델 디자인 방법은 단순합니다. VGG16 모델의 OUTPUT을 분기점으로 하여 새로운 모델 X를 생성한 뒤, 이어 나가면 됩니다. 이후, Model 함수를 통해 입력과 출력을 융합하여 new model를 정의합니다.

예제에서는 64 채널을 가지는 3x3 크기의 CNN과 MaxPooling 레이어를 추가 한 뒤, 2048 - 1024 - 2의 FC를 추가하였습니다. 마지막 출력층은 고양이와 강아지를 분류하는 신경망이기 때문에 2개의 출력, softmax 함수로 구성하였습니다.

4. 새롭게 디자인된 VGG 모델

# CNN Pre-trained 가중치를 그대로 사용할때
for layer in new_model.layers[:19] :
    layer.trainable = False

new_model.summary()

# 컴파일 옵션
new_model.compile(loss='sparse_categorical_crossentropy',
                     optimizer='adam',
                     metrics=['accuracy'])

사전 학습된 VGG16를 Find-Tuning 한다는 것은 전체 네트워크의 가중치를 새롭게 학습하는 것이 아닌 새롭게 추가된 레이어나 말단 부분만을 학습하는 것입니다. 이를 위해 layer.trainable = False를 선언합니다. 새롭게 추가된 층 이외의 VGG16의 19번째 레이어까지 학습하지 않고 고정하였습니다.

5. 학습 데이터 설정

# 테스트 데이터 (고양이/강아지)
train_dir ='train'
test_dir = 'test'

# 폴더에 따라 자동 분류
train_image_generator = ImageDataGenerator(rescale=1./255)
test_image_generator = ImageDataGenerator(rescale=1./255)

# 데이터 구조 생성
train_data_gen = train_image_generator.flow_from_directory(batch_size=16,
                                                           directory=train_dir,
                                                           shuffle=True,
                                                           target_size=(150, 150),
                                                           class_mode='binary')

test_data_gen = test_image_generator.flow_from_directory(batch_size=16,
                                                         directory=test_dir,
                                                         target_size=(150, 150),
                                                         class_mode='binary')

학습을 위한 데이터 전처리는 다양한 방법으로 가능합니다. 본 포스팅에서는 이진 분류기에 적용하기 쉬운 ImageData Generator를 활용하였습니다.

모든 이미지는 신경망 학습 이전에 1./255를 통해 float 형태로 전 처리됩니다.

flow_from_directory 함수

6. 신경망 모델 학습

# 모델 학습
history = new_model.fit(train_data_gen, epochs=5,
                        validation_data=test_data_gen)

new_model.save("newVGG16.h5")                        
                        
# 최종 결과 리포트
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))

from matplotlib import pyplot as plt

plt.plot(epochs, acc, 'r', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='testing acc')
plt.title('Training and testing accuracy')
plt.legend()
plt.figure()

plt.plot(epochs, loss, 'r', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='testing loss')
plt.title('Training and testing loss')
plt.legend()

plt.show()

# 저장 모델 불러오기
from keras.models import load_model

new_model = load_model("newVGG16.h5")

fit을 통해 신경망을 학습합니다. epochs는 반복 학습 횟수이며 학습 데이터와 검증 데이터만 지정해주면 간단한 신경망 학습이 시작되며 콘솔 창에서 실시간 학습 현황이 출력됩니다.

모든 학습이 종료되면 matplotlib를 통해 결과를 그림 2와 같이 그래프화 할 수 있습니다.

그림 2. 최종 학습 결과 그래프

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Tensorflow] 사전 학습된 VGG16 모델로 이미지 분류하기

주식회사 딥아이 — Sun, 13 Dec 2020 17:59:22 +0900

이젠 Imagenet의 방대한 데이터로 사전 학습된 신경망 모델만으로도 충분한 분류 성능을 기대할 수 있게 되었습니다. 물론, 특정한 객체를 집중적으로 분류하기 위해서는 추가 데이터를 통한 미세 학습이 (Find-Tuning)이 필요합니다.

이번 포스팅에서는 학습 모델 구축 이전 대략적인 성능 평가를 할 수 있는 사전 학습 모델로 이미지 분류를 Tensorflow로 구현해 보록 하겠습니다.

그림 1. 이미지넷 데이터 성능평가 결과

텐서 플로우 설치나 사전 학습 모델 불러오는 방법의 상세 설명은 이전 포스팅을 참고하시면 됩니다.

deep-eye.tistory.com/7

[Tensorflow] 아나콘다 가상환경에서 텐서플로우 설치하기

deep-eye.tistory.com

deep-eye.tistory.com/9

[Tensorflow] 텐서플로우에서 사전 학습된 VGG16 모델 불러오기

텐서플로우 설치 포스팅에 이어 사전 학습된 VGG 모델을 활용하는 방법을 살펴보겠습니다. VGG Network는 2014년 이미지넷 인식 학술대회에서 2등을 한 신경망 구조입니다. 본격적으로 층이 깊어지기

deep-eye.tistory.com

0. 소스코드 다운로드

github.com/DEEPI-LAB/python-TensorFlow-Tutorials.git

DEEPI-LAB/python-TensorFlow-Tutorials

Contribute to DEEPI-LAB/python-TensorFlow-Tutorials development by creating an account on GitHub.

github.com

git clone https://github.com/DEEPI-LAB/python-TensorFlow-Tutorials.git

1. 사전학습된 VGG16 모델 불러오기

import cv2
from tensorflow.python.keras.applications.vgg16 import VGG16
from tensorflow.python.keras.preprocessing.image import img_to_array
from tensorflow.python.keras.applications.vgg16 import preprocess_input, decode_predictions

# 사전 학습된 모델 불러오기
model = VGG16(weights='imagenet')

imagenet 데이터로 학습된 가중치를 갖는 VGG16 모델을 불러와줍니다. VGG16은 224x244 x3의 이미지를 입력으로 하는 신경망 구조입니다. 따라서 분류를 위해 입력되는 이미지는 VGG16에 맞게 전처리 해주어야합니다.

2. 이미지 전처리

# 분류를 위한 이미지 불러오기
image = cv2.imread("dog.jpg")
# 이미지 리사이징
image = cv2.resize(image,dsize=(224,224))
image = img_to_array(image)
image = image.reshape((1, image.shape[0],image.shape[1],image.shape[2]))
image = preprocess_input(image)

VGG16 모델의 경우, Tensor flow에서 입력을 위한 전처리 함수들을 제공하고 있으며 아래와 같이 진행됩니다.

이미지 크기 변경 -> 데이터 자료형 변경 -> 텐서 형태로 변경

3. 이미지 분류기 입력

# 클래스 예측
yhat = model.predict(image)
# 클래스 디코딩 (STRING)
label = decode_predictions(yhat)
# 클래스 부여 (최상위 스코어 클래스)
label = label[0][0]
# Result
print("%s (%.2f%%)" % (label[1], label[2]*100))

imagenet 데이터는 총 1000개의 클래스를 갖는 데이터입니다. 따라서 model.predict 함수를 통해 예측된 결과는 1000개의 클래스에 대한 확률 값으로 그림 2와 같이 출력됩니다.

그림 2. VGG16 출력

출력된 1000개의 벡터 중 가장 높은 값을 최종 예측값으로 판단하게 됩니다. 마스크를 쓴 pug 이미지에 대한 결괏값은 69.5% 스코어를 가지는 pug가 가장 높은 값으로 예측되었습니다. 분류에 성공했습니다.

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Matlab] LIDAR 라이다 PCD (Point Cloud Data) 데이터 전처리 #1 KITTI DATASET 활용

주식회사 딥아이 — Thu, 10 Dec 2020 11:49:06 +0900

Concept

한동안 라이다 (LiDAR) 센서 관련 프로젝트를 하면서 PCD(Point Cloud Data) 데이터 분석 업무를 진행했었습니다. 관련 자료가 많이 없다보니 많이 힘들었었던 기억이납니다. PCD는 희소 데이터 특성을 갖는 3차원 공간 데이터이며 현재 다양한 산업 분야에서 활용되고 있습니다.

그림 1. PCD 데이터

비록 테슬라는 다른 길을 걷고 있지만, 최근 제안되는 자율 주행 기술 관련 논문에서는 PCD 데이터를 위치 데이터로 활용하고 있으며 더 나아가 영상과 융합하여 탐지 성능을 향상시키고도 있습니다.

기업이나 연구소 수준에서는 자체 데이터를 이용하지만 저널이나 컨퍼런스에서는 오픈된 데이터로 검증하게 됩니다. 공개 데이터 중, 가장 유명한 데이터는 아마 KITTI-DATASET이 아닐까 싶습니다. 다양한 센서 데이터를 포함하고있어 Detection, Tracking, SLAM 등 다양한 평가에 활용되고 있습니다. 2010년대 초반에 공개된 데이터지만 아직까지 활용도가 높은 데이터입니다.

이번 포스팅 시리즈에서는 KITTI-DATASET에 포함되는 Velodyne 라이다 센서의 PCD 데이터 전처리 과정을 다뤄보겠습니다. 간단한 데이터 전처리부터 지면 데이터 제거, Depth Map 변환 등 기본적으로 응용되고 있는 기법들을 매트랩으로 구현해보도록 하겠습니다.

POST

1.라이다 데이터 전처리 [KITTI DATASET 활용하기]

2. 각도에 따라 라이다 데이터 분할하기 [Segmentation]

3. 변환 행렬을 이용하여 라이다 데이터 축 변환하기 [Transformation]
4. 복셀화를 이용한 LIDAR 라이다 PCD 데이터 압축 [Voxcelization]

SourceCode

1-1. KITTI-DATASET PCD 데이터 다운로드 (30GB)

www.cvlibs.net/datasets/kitti/eval_object.php?obj_benchmark=2d

The KITTI Vision Benchmark Suite

www.cvlibs.net

우선 라이다 데이터가 필요합니다. 센서를 가지고 있다면 괜찮지만, 없다면 공개된 데이터를 받아야겠죠. KITTI의 전체 데이터 용량은 상당히 큽니다. 샘플 데이터는 하단의 링크 또는 GIT CLONE을 통해 받으실 수 있습니다.

1-2. Sample 데이터 및 소스코드 다운로드

github.com/DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab

Contribute to DEEPI-LAB/LiDAR-Point-Cloud-Preprocessing-matlab development by creating an account on GitHub.

github.com

2. BIN FILE OPEN (PCD 데이터 열기)

% load pcd file
lidar_dir = fopen('sample\pcd.bin');
lidar_file = fread(lidar_dir,[4 inf],'single')';
fclose(lidar_dir);

데이터 로드는 fopen으로 쉽게 할 수 있습니다. KITTI-DATASET은 BIN파일 형식으로 제공되며 X축, Y축, Z축, 그리고 Intensity 값이 포함되어있습니다. 라이다 센서는 빛을 쏘고 다시 받는 시간을 측정 (TOF : Time Of Filght) 하여 거리를 측정하게 되는데, 이때 반사된 빛의 강도에 따라 Intensity 값이 PCD에 함께 저장됩니다. 일반적으로 표면의 재질이나 반사각 등에 의해 값이 변하게 되는 성질을 가지고 있습니다.

그림 2. (좌) Intensity 값으로 표현 (중앙) : PCD 밀도 값으로 표현 (우) 최대 높이 값으로 표현

이처럼 라이다 PCD는 객체와의 거리, 높이, 방향, Intensity 정보를 포함하고 있습니다. 영상 카메라에서는 수집할 수 없는 데이터이기 때문에 센서 융합을 통해 보강하고 있으며 많은 자율주행 차량에서 라이다를 부착하는 이유입니다.

3. Preprocessing (PCD 공간 데이터 정의 및 압축)

% X, Y, Z
x_1 = lidar_file(:,1:3); 
% X, Y, Intensity
x_2 = [lidar_file(:,1:2), lidar_file(:,4)];

% preprocessing
x_1(:,3) = round(x_1(:,3),1);
x_2(:,3) = round(x_2(:,3),1);

시각화를 위해 데이터를 X,Y,Z 축 PCD로 구성된 x_1 과 X,Y,Intensity로 구성된 x_2로 나눴습니다. 이후, 데이터가 소숫점 5~6자리까지 표현되면 gscatter 연산이 오래걸리므로 반올림하여 압축하였습니다.

3-1. 2D Visualization

figure(1)
%2D Visualization
subplot(3,1,1)
title('origin')
scatter(x_1(:,1),x_1(:,2),1,'.k')
subplot(3,1,2)
title('height')
gscatter(x_1(:,1),x_1(:,2),x_1(:,3))
legend off
subplot(3,1,3)
title('intensity')
gscatter(x_2(:,1),x_2(:,2),x_2(:,3))
legend off

그림 3. 2차원 Bird Eye View 데이터 시각화

3-2. 3D Visualization

figure(2)
%3D Visualization
subplot(3,1,1)
title('origin')
scatter3(x_1(:,1),x_1(:,2),x_1(:,3),1,'.k')
subplot(3,1,2)
title('height')
gscatter3(x_1(:,1),x_1(:,2),x_1(:,3),x_1(:,3))
legend off
subplot(3,1,3)
title('intensity')
gscatter3(x_2(:,1),x_2(:,2),x_1(:,3),x_2(:,3))
legend off

그림 4. 3D차원 시각화

시각화를하면 멋진 공간 데이터를 볼 수 있지만 10만개가 넘는 데이터를 표현해야하기 때문에 컴퓨터가 상당히 힘들어합니다. 이러한 문제를 해결하기 위해 불필요한 각도나 위치의 데이터를 줄이고, 필요 이상의 데이터를 압축하고 있습니다. 다음 포스팅에서는 축 변환과 각도 분할 방법 등을 활용해서 데이터를 압축하고 제거하는 알고리즘을 구현해보도록 하겠습니다.

4. gscatter3 함수

kr.mathworks.com/matlabcentral/fileexchange/37970-gscatter3

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Python] 파이썬을 이용한 DBSCAN 군집화 알고리즘 구현

주식회사 딥아이 — Tue, 8 Dec 2020 00:08:59 +0900

Concept

DBSCAN (Density-based Spatial Clustering of Applications with Noise)은 비선형 클러스터의 군집이나 다양한 크기를 갖는 공간 데이터를 보다 효과적으로 군집하기 위해 이웃한 개체와의 밀도를 계산하여 군집하는 기법입니다.

K-Means와 같이 군집 이전에 클러스터의 개수가 필요하지 않고 잡음에 대한 강인성이 높기 때문에 현재까지도 다양한 분야에서 활용되고 있습니다. 이번 포스팅에서는 파이썬을 이용해서 DBSCAN 알고리즘을 구현해보도록 하겠습니다.

그림 1. 클러스터링 결과 (좌) K-MEANS (우) DBSCAN

Algorithm

사실 DBSCAN은 컴퓨팅 알고리즘으로 제안된 기법이기 때문에 특별한 수식이 존재하지 않습니다. 2가지 파라미터만 기억하면 됩니다. 이웃과의 거리를 나타내는 최소 이웃 반경 $\epsilon$ 과 최소 이웃 수 $minPts$입니다.

1. 각각의 객체들은 반경 $\epsilon$ 을 기준으로 최소 이웃 $minPts$ 이상을 충족하면 군집
2. 최소 이웃 $minPts$를 충족하지 못하면 잡음으로 판단
3. 군집되었다면 군집된 이웃 객체를 대상으로 1번 반복

그림 2. 이웃 객체와의 밀도를 기반으로 군집하는 DBSCAN

K-Means처럼 전체 데이터의 분포 특성을 통해 중심점을 추정하는 방식이 아닌, 개별적인 객체 하나하나의 밀도 특성을 1-3번 알고리즘을 반복하며 군집하게 됩니다. 모든 객체는 한 번 연산된 이후에는 다시 군집되는 일이 업도록 Flag를 지정해줍니다. 처음 시작하는 객체는 초기화를 통해 무작위로 뽑히게 되며 군집이 완료되면 그림 2와 같이 군집에 속하는 Core와 Border, 그리고 Outlier로 판단되는 Noise 값으로 분류할 수 있습니다.

Core Vector(object) : 임의의 벡터로부터 반경 $\epsilon$내에 있는 이웃 벡터의 수가 $minPts$보다 클 경우, 하나의 군집을 생성하며 중심이 되는 벡터
Border Vector(object) : 핵심 벡터로부터 거리 $\epsilon$내에 위치해서 같은 군집으로 분류되나, 그 자체로는 핵심 벡터가 아닌, 군집의 외각에 위치하는 벡터
Noise Vector(object) : 핵심 또는 외각 벡터가 아닌, 즉 $\epsilon$ 이내에 $mitPts$개 미만의 백터가 있으며, 그 벡터들 모두 핵심 백터가 아닐 경우, 어떠한 군집에도 속하지 않는 벡터

그림 3. DBSCAN 군집 과정

Complexity

클러스터링 분야에서는 빅데이터를 다루는 만큼 연산 복잡성이나 메모리 등을 고려해야 합니다. 일반적인 DBSCAN은 각 객체와 객체 사이의 모든 거리가 필요합니다. 군집 과정에서도 하나하나 군집되기 때문에 시간 연산 복잡성은 보통 전체 데이터가 $N$개 일 때, $O(Nlog(N)) ~ O(N^2)$ 정도입니다. 그래프 기반 클러스터링 $O(N^3)$ 보다는 매우 낮지만 데이터가 방대해지면 무시 못할 수준인 것 같습니다.

Python Code

사용된 라이브러리는 Numpy, Scipy 그리고 Plot 표현을 위한 Matplotlib입니다. 기초적인 수준에서 활용하였기에 버전 이슈는 크게 없을 것 같습니다. git 또는 링크를 통해 압축 파일 형태로 받아주세요.

필수 라이브러리

pip install numpy scipy matplotlib

소스 코드 다운로드

git clone https://github.com/DEEPI-LAB/dbscan-python.git

github.com/DEEPI-LAB/dbscan-python

DEEPI-LAB/dbscan-python

Contribute to DEEPI-LAB/dbscan-python development by creating an account on GitHub.

github.com

0. DBSCAN 파라미터 초기화

def __init__(self,x,epsilon,minpts): 
    # The number of input dataset
    self.n = len(x)
    # Euclidean distance
    p, q = np.meshgrid(np.arange(self.n), np.arange(self.n))
    self.dist = np.sqrt(np.sum(((x[p] - x[q])**2),2))
    # label as visited points and noise
    self.visited = np.full((self.n), False)
    self.noise = np.full((self.n),False)
    # DBSCAN Parameters
    self.epsilon = epsilon
    self.minpts = minpts 
    # Cluseter
    self.idx = np.full((self.n),0)
    self.C = 0
    self.input = x

입력 X, 최소 이웃 반경 epsilon, 최소 이웃 개수 minpts를 입력으로 하는 DBSCAN 클래스로 코드를 구현했습니다. 군집 이전 모든 객체의 초기 인덱스(self.index)는 0으로 초기화했으며, 방문 flag(self.visited)와 잡음 인덱스(self.noise)를 통해 한 번 연산된 객체와 잡음 객체는 다시 연산되지 않도록 하였습니다.

1. DBSCAN 군집 단계 #1

def run(self):
    # Clustering
    for i,vector in enumerate(x):
        if self.visited[i] == False:
            self.visited[i] = True
            self.neighbors = self.regionQuery(i)
            if len(self.neighbors) > self.minpts:    
                self.C += 1    
                self.expandCluster(i)    
            else : self.noise[i] = True 

    return self.idx,self.noise

# 최소 반경 이내 최소 이웃 수를 만족하는 군집 찾기
def regionQuery(self, i):
    g = self.dist[i,:] < self.epsilon 
    Neighbors = np.where(g == True)[0].tolist()

    return Neighbors

입력 데이터를 스캔하며 방문 flag를 체크합니다. False일 경우, RegionQuery 함수로 군집 밀도를 충족하는지 판단합니다. 군집 요건을 만족하게 되면 군집된 이웃 객체를 대상으로 RegionQuery를 다시 반복하기 위해 ExpandCluster 함수를 실행해줍니다.

2. DBSCAN 군집 단계 #2

def expandCluster(self, i):
    self.idx[i] = self.C
    k = 0
    
    while True:
        try:
            j = self.neighbors[k]
        except:pass
        if self.visited[j] != True:
            self.visited[j] = True
            
            self.neighbors2 = self.regionQuery(j)
            
            if len(self.neighbors2) > self.minpts:
                self.neighbors = self.neighbors+self.neighbors2
                
        if self.idx[j] == 0 :  self.idx[j] = self.C 
      
        k += 1
        if len(self.neighbors) < k:
            return

3. 최종 코드

# -*- coding: utf-8 -*-
"""
Project Code: DBSCAN v1.0
@author: Deep.I Inc. @Jongwon Kim
Revision date: 2020-12-07
Contact Info: :
    https://deep-eye.tistory.com
    https://deep-i.net
"""

import numpy as np
from scipy import io
from matplotlib import pyplot as plt

class DBSCAN(object):

    def __init__(self,x,epsilon,minpts): 
        # The number of input dataset
        self.n = len(x)
        # Euclidean distance
        p, q = np.meshgrid(np.arange(self.n), np.arange(self.n))
        self.dist = np.sqrt(np.sum(((x[p] - x[q])**2),2))
        # label as visited points and noise
        self.visited = np.full((self.n), False)
        self.noise = np.full((self.n),False)
        # DBSCAN Parameters
        self.epsilon = epsilon
        self.minpts = minpts 
        # Cluseter
        self.idx = np.full((self.n),0)
        self.C = 0
        self.input = x
        
    def run(self):
        # Clustering
        for i,vector in enumerate(x):
            if self.visited[i] == False:
                self.visited[i] = True
                self.neighbors = self.regionQuery(i)
                if len(self.neighbors) > self.minpts:    
                    self.C += 1    
                    self.expandCluster(i)    
                else : self.noise[i] = True 
    
        return self.idx,self.noise
                            
    def regionQuery(self, i):
        g = self.dist[i,:] < self.epsilon 
        Neighbors = np.where(g == True)[0].tolist()
    
        return Neighbors     
    
    def expandCluster(self, i):
        self.idx[i] = self.C
        k = 0
        
        while True:
            try:
                j = self.neighbors[k]
            except:pass
            if self.visited[j] != True:
                self.visited[j] = True
                
                self.neighbors2 = self.regionQuery(j)
                
                if len(self.neighbors2) > self.minpts:
                    self.neighbors = self.neighbors+self.neighbors2
                    
            if self.idx[j] == 0 :  self.idx[j] = self.C 
          
            k += 1
            if len(self.neighbors) < k:
                return
            
    def sort(self):
        
        cnum = np.max(self.idx)
        self.cluster = []
        self.noise = []
        for i in range(cnum):
           
            k = np.where(self.idx == (i+1))[0].tolist()
            self.cluster.append([self.input[k,:]])
       
        self.noise = self.input[np.where(self.idx == 0)[0].tolist(),:]
        return self.cluster, self.noise
              
    def plot(self):
        
        self.sort()
        fig, ax = plt.subplots()
        
        for idx,group in enumerate(self.cluster):
        
            ax.plot(group[0][:,0], 
                    group[0][:,1], 
                    marker='o', 
                    linestyle='',
                    label=idx) 
        ax.plot(noise[:,0], 
                noise[:,1], 
                marker='x', 
                linestyle='',
                label='noise')        

        ax.legend(fontsize=10, loc='upper left')
        plt.title('Scatter Plot of Clustering results', fontsize=15)
        plt.xlabel('X', fontsize=14)
        plt.ylabel('Y', fontsize=14)
        plt.show()

Results

그림 4. DBSCAN 결과

사용된 2차원 공간 데이터 링크

github.com/DEEPI-LAB/clustering-dataset

DEEPI-LAB/clustering-dataset

2d spatial dataset for clustering evaluation. Contribute to DEEPI-LAB/clustering-dataset development by creating an account on GitHub.

github.com

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[Matlab] 다층 퍼셉트론(MLP)을 이용한 MNIST 손글씨 인식 알고리즘 구현

주식회사 딥아이 — Sat, 5 Dec 2020 16:00:29 +0900

MNIST DATASET

MNIST 데이터셋은 머신러닝을 입문하는 분들이 처음 접하게 되는 데이터 중 하나입니다. 28 x 28 해상도를 가지는 흑백 이미지로 구성되어있지만, 영상 처리 알고리즘 이외 K-Measn, PCA, RNN 등 다양항 기법이 적용 가능하여 초기 데이터 분석 단계에서 연습에 활용되고 있습니다.

저 역시 처음 머신러닝에 입문했을 때 XOR 게이트 문제 이후, 머리를 쓰며 가장 많이 다뤄본 데이터입니다. 이제 막 입문하시는 분들이라면 Tesnorflow 나 Pytorch가 제공하는 함수 사용 이전에 직접 수식을 코딩하고 데이터 전처리하는 연습은 꼭 가지시길 바랍니다. 그런 의미에서 이번 포스팅에서는 모두를 위한 인공지능 교육에 활용했었던 MATLAB 기반 MINIST 손글씨 인식 알고리즘 코드를 구현하겠습니다. 모든 코드는 함수없이 직접 구현되었습니다.

MULTI-LAYER PERCEPTRON

2개의 은닉층을 가지는 MLP 구조로 설계하도록 하겠습니다. MLP는 CNN처럼 2차원 영상이 입력될 수 없기 때문에 1차원으로 데이터를 변환시켜줘야 합니다. 28 X 28 이미지는 784 개의 1차원 벡터로 변환되어 N개의 노드를 가지는 은닉층에 입력됩니다. 첨부된 데이터는 총 60,000개이며 784개의 차원을 가지므로 60,000 x 784 의 형태를 가지게 됩니다.

Algorithm

0. 샘플코드 다운로드

github.com/DEEPI-LAB/matlab-mnist-multi-layer-perceptron.git

DEEPI-LAB/matlab-mnist-multi-layer-perceptron

The repository implements the a simple Multi-Layers Neural Network from scratch for MNIST classification. - DEEPI-LAB/matlab-mnist-multi-layer-perceptron

github.com

git clone https://github.com/DEEPI-LAB/matlab-mnist-multi-layer-perceptron.git

또는 위 링크에서 좌측 상단 초록색 CODE를 클릭 후, 하단 Download ZIP 으로 직접 다운로드 가능합니다.

1. 데이터 확인

%% MNIST 데이터 확인                                            
mnist = images(:,1:200);                        
mnist = reshape(mnist,28,28,200); 
montage(mnist)

2. 신경망 구조 설계 및 미니 배치 크기 설정

% 1st Layer
node_1w = fc_node('weight', imRe^2, pNum_1);
node_1b = fc_node('bias', pNum_1,1);
% 2nd Layer
node_2w = fc_node('weight', pNum_1, pNum_2);
node_2b = fc_node('bias', pNum_2,1);
% 3rd Layer
node_3w = fc_node('weight', pNum_2, 10);
node_3b = fc_node('bias', 10,1);
% batch size
batch =64;

입력 벡터의 크기와 일치하도록 은닉층 노드 수를 설정하고 가중치값과 편향 값을 randn 함수로 초기화 해줍니다. 학습은 미니 배치 방식으로 64개씩 학습을 진행했습니다.

3. 학습 데이터 셔플링 및 미니 배치 메모리 지정

% data shuffle
p = randperm(cols);                                           
X = x(:,p(1:batch));
Y = y(p(1:batch),:);

% batch memory init (weight)
batch_1 = 0; batch_2 = 0; batch_3 = 0; 
% batch memory init (bias)
batch_4 = 0; batch_5 = 0; batch_6 = 0;

학습을 반복하면서 자동으로 데이터가 섞일 수 있도록 randperm 함수를 이용하여 셔플링을 진행해줍니다. 병렬 처리 프로세스가 아닌 For문으로 모든 미니 배치 데이터 값을 연산해야 하기 때문에 배치 메모리를 사전에 지정하는 방식으로 미내 배치 학습을 구현했습니다.

4. 순전파 단계

%% Feed Forward propagation

f1 = relu(X(:,i)' * node_1w + node_1b');
f2 = relu(f1 * node_2w + node_2b');
f3 = exp(f2 * node_3w + node_3b') / sum(exp(f2 * node_3w + node_3b')) ;

5. 오차 함수 단계

%% Error
P(i) = find(f3==max(f3));
O(i) = find(Y(i,:)==max(Y(i,:)));
E(i,:) = - sum(Y(i,:).*log(f3));

6. 역전파 단계

%% Back propagation  

b3 = f3 - Y(i,:);    
b2 = b3 * node_3w' .* reluGradient(f2);     
b1 = b2 * node_2w' .* reluGradient(f1);

MNIST는 0부터 1까지 총 10개의 클래스를 가지고 있으므로 크로스 엔트로피를 오차 함수로 설정했습니다. 활성화 함수는 순 전파 역전파 모두 구현이 쉽고 성능에서도 Sigmoid 대비 우위를 가지고 있는 ReLu 함수를 사용했습니다.

7. 미니 배치 업데이트 단계

%% Batch 
         batch_1 = batch_1 + (alpha * f2' * b3);        
         batch_4 = batch_4 + (alpha * b3)'; 
         
         batch_2 = batch_2 + (alpha * f1' * b2);   
         batch_5 = batch_5 + (alpha * b2)';
    
         batch_3=  batch_3 + (alpha * X(:,i) * b1);
         batch_6 = batch_6 + (alpha * b1)' ;
         
    end
    
        %% Update
        node_3w = node_3w - batch_1 / batch;
        node_2w = node_2w - batch_2 / batch;
        node_1w = node_1w - batch_3 / batch;
        
        node_3b = node_3b - batch_4 / batch;
        node_2b = node_2b - batch_5 / batch;
        node_1b = node_1b - batch_6 / batch;

For문 연산으로 미니배치만큼 역전파 값을 구해 준 뒤, 모두 더한 다음 가중치와 편향 값을 업데이트하게 됩니다. 매트랩이 취약한 For문이 넘쳐흐르네요. 어느 정도 역전파와 배치에 대한 이해도가 높으신 분들은 병렬 처리 프로세서 방식으로 변경해 보시길 바랍니다.

8. 전체 코드 및 결과

% *********************************************
% MNIST Neural Networks
% @author: Deep.I Inc. @Jongwon Kim
% deepi.contact.us@gmail.com
% Revision date: 2020-12-01
% See here for more information :
%    https://deep-eye.tistory.com
%    https://deep-i.net
% **********************************************
% STRUCTURE : BATCH MLP
% input : 787 x 60000
% output : 10 x 60000
% MODE : Batch
% ACTIVATION FUNCTION : 'Relu'
% ERROR RATE : 2.51

%% F5를 눌러서 실행해주세요.

clear all
clc
cla
close all
input("\n\n 퍼셉트론을 활용한 손글씨 인식 프로그램 입니다. [엔터키를 눌러주세요] ")

%%
load train\train_input.mat; 
load train\train_output.mat; 

clc
input("\n\n 배포해드린 숫자 데이터를 로드할게요. [엔터키를 눌러주세요] ")                                              
                                              
%% 학습 데이터를 한번 봅시다                                              
mnist = images(:,1:200);                        
mnist = reshape(mnist,28,28,200); 
montage(mnist)                                      

title("학습에 활용할 손글씨 이미지 입니다. [엔터키를 눌러주세요] ")
clc
input("\n\n 학습에 활용할 손글씨 이미지 입니다. [엔터키를 눌러주세요] ")

x = images;
cols = size(x,2);
imRe = 28;
    
clc
fprintf("데이터의 개수 : %d \n이미지 해상도 : %d x %d\n입력 차원 : %d\n",cols,imRe,imRe,imRe^2)
alpha = input("\n\n 학습의 정도를 결정하는 Learning Rate을 입력해주세요. [0.1~ 0.0001] ");
clc
pNum_1  = input("\n\n 첫번째 층의 퍼셉트론(뉴런)의 개수를 입력해주세요. [1~inf] ");
pNum_2  = input(" 두번째 층의 퍼셉트론(뉴런)의 개수를 입력해주세요. [1~inf] ");
eh  = input(" 학습을 몇번 반복할지 반복 횟수를 입력해주세요. [1~inf] ");
fprintf("\n\n %d-%d-%d-%d 의 구조를 갖는 신경망이 완성되었습니다.",imRe^2,pNum_1,pNum_2,10);
input(" 엔터를 누루면 학습을 시작합니다!");

% 1st Layer
node_1w = fc_node('weight', imRe^2, pNum_1);
node_1b = fc_node('bias', pNum_1,1);
% 2nd Layer
node_2w = fc_node('weight', pNum_1, pNum_2);
node_2b = fc_node('bias', pNum_2,1);
% 3rd Layer
node_3w = fc_node('weight', pNum_2, 10);
node_3b = fc_node('bias', 10,1);
% batch size
batch =64;

close all
for z = 1 : eh
    
% data shuffle
p = randperm(cols);                                           
X = x(:,p(1:batch));
Y = y(p(1:batch),:);

% batch memory init (weight)
batch_1 = 0; batch_2 = 0; batch_3 = 0; 
% batch memory init (bias)
batch_4 = 0; batch_5 = 0; batch_6 = 0;
        
    for i = 1 : batch    

%% Feed Forward propagation

f1 = relu(X(:,i)' * node_1w + node_1b');
f2 = relu(f1 * node_2w + node_2b');
f3 = exp(f2 * node_3w + node_3b') / sum(exp(f2 * node_3w + node_3b')) ;
        
%% Error
P(i) = find(f3==max(f3));
O(i) = find(Y(i,:)==max(Y(i,:)));
E(i,:) = - sum(Y(i,:).*log(f3));
        
        
%% Back propagation  

b3 = f3 - Y(i,:);    
b2 = b3 * node_3w' .* reluGradient(f2);     
b1 = b2 * node_2w' .* reluGradient(f1);
       
        %% Batch 
         batch_1 = batch_1 + (alpha * f2' * b3);        
         batch_4 = batch_4 + (alpha * b3)'; 
         
         batch_2 = batch_2 + (alpha * f1' * b2);   
         batch_5 = batch_5 + (alpha * b2)';
    
         batch_3=  batch_3 + (alpha * X(:,i) * b1);
         batch_6 = batch_6 + (alpha * b1)' ;
         
    end
    
        %% Update
        node_3w = node_3w - batch_1 / batch;
        node_2w = node_2w - batch_2 / batch;
        node_1w = node_1w - batch_3 / batch;
        
        node_3b = node_3b - batch_4 / batch;
        node_2b = node_2b - batch_5 / batch;
        node_1b = node_1b - batch_6 / batch;
        
        %% 그래프 보기
        tex2 = mean(P == O);
        tex1 = mean(E);
        mse(z,1) = mean(E);
        format shortG
        clc        
        fprintf("학습 횟수 : %d번\n",z)
        fprintf("학습된 글자 수 : %d 개 (한 번 반복에 64개씩 학습을 진행합니다.)\n",z*batch)
        fprintf("학습 데이터 손글씨 인식률 : %0.2f%%\n",round(tex2*100,4))
        fprintf("전체 학습 오차(MSE) : %0.5f",round(tex1,4))
        cla
        subplot(1,2,1)
        plot(mse);
        axis([0 inf 0 5])
        title("MSE")
        drawnow;
        subplot(1,2,2)
        
        testing = reshape(X,28,28,64);
        montage(testing(:,:,1:20));
        title("학습중인 숫자")
        drawnow;
        %
end
clc
fprintf("학습 횟수 : %d번\n",z)
fprintf("학습된 글자 수 : %d 개 (한 번 반복에 64개씩 학습을 진행합니다.)\n",z*batch)
fprintf("학습 데이터 손글씨 인식률 : %0.2f%%\n",round(tex2*100,4))
fprintf("전체 학습 오차(MSE) : %0.5f",round(tex1,4))
input("    학습이 완료되었습니다. 테스트 데이터로 실험을 해봅시다!")

%%
load test\test_input.mat; 
load test\test_output.mat; 

results = [];
for i= 1 : 10000
    f1 = relu(test(:,i)' * node_1w + node_1b');
    f2 = relu(f1 * node_2w + node_2b');
    f3 = exp(f2 * node_3w + node_3b') / sum(exp(f2 * node_3w + node_3b'));
    results(i) =  min( yy(i,:) == (f3 ==max(f3)));
end

fprintf("전체 테스트 데이터 학습 결과 %0.2f %% 정확도\n",round(mean(results)*100,2))

results = [];
for i= 1 : 10
    f1 = relu(test(:,i)' * node_1w + node_1b');
    f2 = relu(f1 * node_2w + node_2b');
    f3 = exp(f2 * node_3w + node_3b') / sum(exp(f2 * node_3w + node_3b'));
    results(i) =  min( yy(i,:) == (f3 ==max(f3)));
    
    im = reshape(test(:,i)',28,28);
    imshow(im);
    title(find(f3 ==max(f3))-1)
    input("")
end

CNN 분류 모델과 비교하여 단순한 기법이지만 MNIST 학습 성능은 평균적으로 95 ~ 98% 수준으로 높습니다. 첨부된 코드에서 학습 성능 향상을 위해 개선된 부분은 다음과 같습니다.

데이터 셔플링, ReLu 함수, 크로스 앤트로피 오차

현대의 신경망에는 이외에 다양한 기술적 테크닉이 존재합니다. 함수 구현이 아닌, 이론을 통해 이해가 된 알고리즘을 자신만의 코드로 변환하여 MNIST의 성능을 향상해보시길 바랍니다.

[2020-12-03] Jetson AGX Xavier 모듈 및 케리어 보드 구입

주식회사 딥아이 — Thu, 3 Dec 2020 15:48:59 +0900

NVIDIA JETSON AGX

진행중인 프로젝트의 시제품 개발을 위해 Jetson AGX Xavier 모듈과 케리어보드를 구입했습니다. Jetson AGX 개발자 키트의 경우 작년부터 잘 사용하고 있었지만, 보다 최적화된 시스템 구축을 위해서는 모듈이 적합하다 판단되어 이번에 한국 총판 한컴 MDS에서 구매하게 됬습니다.

가격이 후덜덜한 만큼 성능도 압도적입니다. YOLO v4 416 모델을 기준으로 평균 30프레임 정도의 성능을 가지고 있습니다. GPU 성능은 좋지만, 다소 아쉬운점은 CPU 연산능력은 조금 떨어진다는 점입니다. Tracking Algorithm 구현을 위해 Kalman Filter 기반의 SORT를 평가해보니 객체 수가 많아지면 프레임 드랍이 심하게 발생하더군요. 이 크기에서 더 좋은 성능을 바라면 안되지만, 다소 아쉬운 점입니다. 추후 Jetson 시리즈 성능 리뷰를 한번 진행해야겠네요.

AGX Xavier module 외형

좌측이 Xavier 모듈, 우측이 Xavier 개발자 키트입니다. 마치 초콜릿바같이 아기자기하게 생겼습니다. 모듈이지만 외형 디자인이 세련되있으며 생각보다 무게가 많이 나갑니다. AGX 개발자 키트와 동일한 크기입니다. TX2의 경우 개발자 키드는 모듈에 비해 너무 커서 조금 아쉬웠는데, AGX는 정말 컴펙트한 크기로 잘 나온것 같습니다.

AGX Xavier module Carrier Board 외형

함께 구매하게된 Avermidia 사의 케리어 보드입니다. 개발자 키드의 세련됨은 없지만 많은 인터페이스 모듈을 가지고 있어 확장성이 우수한것같습니다. 기존 TX2의 케리어 보드와 비슷한 크기를 가지고 있습니다.

[2020-12-01] 구글 애드센스 심사 승인

주식회사 딥아이 — Wed, 2 Dec 2020 20:49:14 +0900

[2020-12-01] 구글 애드센스 심사 승인

안녕하세요. 딥아이입니다. 학술 정보나 딥러닝 프로그래밍 관련 자료를 정리하고 공유하기 위해 블로그를 개설한 지 반년이 되어갑니다. 그동안 이런저런 핑계로 방치해두다 이러면 안 되겠다 싶어 매일매일 퇴근 후 열심히 포스팅하고 있습니다. 크나큰 수익을 바라지는 않지만, 보다 동기부여가 되고 확장 가능성을 검증하고 싶어 구글 애드센스 심사를 받게 되었습니다.

승인 완료

포스팅 수 26개 시점에서 심사를 받았으며, 약 하루 후 승인 메일이 도착했습니다. 어렵다고 하시는 분들도 계셨는데 딥 아이는 운이 좋았던 것 같습니다. 광고가 붙은 글을 보니 뭔가 뿌듯하기도 한 것 같습니다. 앞으로 더욱 완성도 높은 블로그가 되도록 노력하겠습니다.

[Python] 스터디 윗미 타이머 프로그램 Study With DI

주식회사 딥아이 — Wed, 2 Dec 2020 16:40:16 +0900

With DI ver - 1.2.0 + (2022.05.16)

스터디윗미 방송이나 PC 환경에서 공부하시는 분들을 위한 타이머 프로그램 위드디(with DI)입니다.

그동안 업무로 정신이 없어서 업데이트를 못했습니다. 이번 1월 내로, 업데이트 진행해서 다시 배포하겠습니다.

(2024.01.02)

긴급 업데이트(2021.05.16)

1. 서버 문제를 해결하기 위해 오프라인 모드로 변경하였습니다.

최신 업데이트 (2021.04.12)

1. 이제 공부 횟수가 무제한이 됩니다. 팬이 뿌셔지도록 함께 공부할 수 있습니다.

2. 더이상 위젯이 상단에 고정되지 않습니다.

3. 후원하기 기능이 추가되었습니다. 서비스 개선을 위해 많은 후원 부탁드립니다.

4. 고인물 방지를 위해 이제 공부 랭킹은 1주 단위로 업데이트됩니다.

5. 순위권 내 스트리머의 경우, 이제 실시간으로 자신의 방송국을 DI RANK를 통해 홍보할 수 있습니다.

6. 종료 시간에 휴식시간이 무시되는 버그를 수정했습니다.

7. 이제 시작 종소리가 울립니다.

8. 1.2.0 버전 이후 수집 방법이 일부 변경되어 이전 버전 사용자의 경우 랭크가 적용되지 않습니다.

다음 업데이트 예정

1. MAC 호환 버전 추가 (업무량으로 인해 엄두가 안나요ㅠㅜ)

2. 유투브 홍보 링크 또는 이미지 도입 여부 생각중

3. 유투브 실시간 채팅 방지처럼 공부를 위해 실시간은 아니지만 1분 단위, 10분 단위 정도로 함께 채팅할 수 있는 공간 생각 중

스터디 위드미 관련 문의사항이 있을경우, 빠른 답변이 가능한 오픈채팅방을 개설했습니다.

open.kakao.com/o/g1mlSv8c

Study With Di

open.kakao.com

후원하기 버튼이 생겼어요!

핵심 기능

OBS 방송 프로그램에 맞게 텍스트 파일로 타이머가 동작하는 방식
현재 날짜, 현재 시간, 공부 시간, 휴식 시간, 식사 시간 등을 타이머로 설정
종소리 / 타이머 형식 설정
ASMR 음악 링크 재생
DI RANK 누적 공부시간 순위
위젯을 통한 시각적 효과 배너 설정
자동 업데이트

상세 사용 방법

deep-eye.tistory.com/52

[Study With DI] 스터디 윗미 타이머 위젯 설정 방법

Download Link deep-eye.tistory.com/32 [Python] 스터디 윗미 타이머 프로그램 Study With DI With DI ver - 1.0.0 스터디윗미 방송이나 PC 환경에서 공부하시는 분들을 위한 타이머 프로그램 위드디(with DI)입..

deep-eye.tistory.com

사용 방법 #1 (WithDI 초기 설정)

설치 프로그램을 다운받은뒤 압축 해제해줍니다.

[이전 버전 파일 링크]
[배포판 링크 40mb] ~~[배포판 자동 설치 파일 링크 7mb]~~
배포판의 경우 바로 run.exe을, 자동 설치 파일의 경우 path.exe를 실행해주세요.
개인 배포 프로그램이기 때문에 백신 경고가 발생합니다. 무시한 뒤, 관리자 권한으로 실행해주시면 됩니다. 백신 프로그램에 따라 파일을 자동으로 삭제하거나 방화벽에서 패치를 막는 경우가 있습니다. 상용 프로그램이 아니기때문에 사용자가 적어 어쩔수 없는 한계인듯 합니다. 백신을 잠시 꺼주시거나 검사 항목에서 제외를 해주시면 됩니다.
사용을 원하는 타이머의 형식을 지정해줍니다. 출력되는 문구는 실제 방송에서 표현되는 텍스트입니다.
[Today 설정]-[Study 설정]-[Sound 설정]을 완료 한 뒤, 하단의 Start 버튼을 클릭해주세요.
모든 타이머를 설정할 필요는 없습니다. 필요한 기능만 연동하면 됩니다.
시작 시간이 경과하면 타이머가 시작됩니다.
[Streaming] 탭에서 현재 타이머를 확인할 수 있습니다.
[Widget] 탭에서 위젯을 추가로 실행할 수 있습니다.

사용 방법 #2 (OBS 연동 설정)

OBS 프로그램에서 텍스트 소스를 추가해줍니다.
파일에서 불러들이기를 체크해주시고 복사된 경로의 텍스트 파일을 지정해줍니다.
타이머가 작동 중이라면 텍스트 파일이 1초 간격으로 업데이트됩니다.
OBS 텍스트 속성에서 폰트와 색상 등을 변경해주시면 됩니다.
위젯의 경우, 응용 프로그램 소스를 추가하여 실행 중인 위젯을 클릭하면 됩니다.

다운로드

소스코드 (python) : https://github.com/DEEPI-LAB/python-study-with-me-timer.git

DEEPI-LAB/python-study-with-me-timer

스터디윗미 방송이나 PC 환경에서 공부하시는 분들을 위한 타이머 프로그램 위드디(with DI)입니다. - DEEPI-LAB/python-study-with-me-timer

github.com

배포판 (windows10/7) : https://drive.google.com/file/d/1J64QTsQikO4AhohP2P5S-aCSBpis-bef/view?usp=sharing

WithDI_1.2.0.zip

스터디윗미 타이머 프로그램

drive.google.com

패치노트

[2021-01-12 ver 0.9.8]

- 종소리 음원 추가

- DI RANK 시스템 추가

- UI 레이아웃 개선

- 권한 충돌 오류 수정

[2021-01-22 ver 0.9.9]

- 타이머 오류 수정

- 자동 패치 기능 추가

- 공부 종료 타이머 정지 오류 발생

[2021-01-26 ver 1.0.0]

- 위젯 시스템 최적화
- 랭킹 시스템 최적화
- 타이머 시스템 최적화
- 음원 재생 충돌 오류 수정

[2021-01-31 ver 1.0.1]

- 시간표 위젯 추가
- 타이머 일시 정지 버튼 추가
- 타이머 다시 시작 버튼 추가
- 서버 연동 데이터 전송 방식 변경
- UI 오류 수정

[2021-02-18 ver 1.1.0]

- 스톱 워치 위젯 추가
- 스톱 워치 텍스트 생성 기능 추가
- 카운트 업 & 다운 텍스트 기능 추가
- 텍스트 파일명 수정
- UI 개선

[2021-04-12 ver 1.2.0]

- 후원 링크 추가

- 유투브 링크 삭제

- 종료 시간 버그 수정

- UI 개선

- 위젯 고정 해제

- 시간 배수 무제한 변경

- 기타 버그 수정

Contact Us

사용방법 및 오류 관련 문의는 댓글 남겨주세요.

방송에 최적화된 타이머 제작이나 기능 관련 문의는 메일 주세요.

blog : https://deep-eye.tistory.com
mail : deepi.contact.us@gmail.com
YouTube : www.youtube.com/channel/UCi18EeOdU26XvfKzcOMW3XA/featured

딥아이 DEEP.I | AI 기반 지능형 기업 솔루션

deep-i.ai

[YOLO] 객체 탐지 알고리즘 학습을 위한 이미지 데이터 라벨링 #3 YOLO 라벨링 프로그램

주식회사 딥아이 — Wed, 2 Dec 2020 02:08:07 +0900

이미지나 영상에서 객체를 지능적으로 찾기 위해 제안된 객체 탐지 알고리즘은 RCNN 계열과 더불어 SDD와 YOLO 등 다양한 기법으로 파생되고 있습니다. 하지만 아직까지 실제 현업 application 단계에서의 실용성과 효율성 문제, 구현 난이도로 인해 YOLO가 압도적으로 활용되고 있는 것 같습니다. 이번 포스팅에서는 YOLO 학습을 위한 데이터 라벨링 프로그램 하나를 소개하려 합니다.

github.com/developer0hye/Yolo_Label

developer0hye/Yolo_Label

GUI for marking bounded boxes of objects in images for training neural network Yolo v3 and v2 https://github.com/AlexeyAB/darknet, https://github.com/pjreddie/darknet - developer0hye/Yolo_Label

github.com

소개하려고 보니 한국분이시네요. 상당히 재미있고 유쾌하신 분인 것 같습니다. 기존 라벨링 업무의 지루함과 불편함을 해소하기 위해 제작하셨다고 합니다. 원문을 읽고 사용법을 익히셔도 될 정도로 직관적이고 쉬운 프로그램입니다.

0. 설치하기

윈도 환경을 기준으로 작성하도록 하겠습니다. 제작자 링크 또는 여기를 통해 다운로드하시면 됩니다. 설치 후 YoloLabel.exe를 실행하면 준비 끝입니다.

1. 데이터 및 라벨 구축

그림 1. 기본 실행 화면

최근 유행하는 레트로 감성이 라벨링 업무까지 전해졌습니다. 좌측 하단의 Open Files를 클릭 후, 이미지 데이터가 포함되어있는 폴더 경로를 지정해주세요. 이미지 개수 대비 로딩도 상당히 빠른 편입니다.

그림 2. 라벨 파일 (txt 또는 names 파일)

이후, 목표하는 분류 라벨 정보가 있는 텍스트 파일을 지정해주어야 합니다. txt나 names 상관없지만 일반적으로 학습과 구현 단계에서 names를 사용하니 혼돈이 없도록 후자의 형식으로 텍스트 파일 확장자를 변경해서 사용하시길 바랍니다.

라벨은 간단합니다. 목표하는 라벨을 그림 2와 같이 한 라인에 한 개씩 지정해주면 됩니다. 한글까지 지원되니 라벨링을 좀 더? 수월하게 하 실 수 있습니다.

주의 : 데이터 폴더와 라벨 파일의 경로에 공백이 없도록 해주세요. 예를 들어

지정된 경로의 폴더명이 '데이터 파일'이 아닌 '데이터_파일'로 변경해주시길 바랍니다.

그림 3. 좀 덜 지루한? 라벨링 작업의 시작

정상적으로 실행이 되었다면, 데이터 이미지와 우측의 라벨 정보가 표현됩니다. 십자선이 뚜렷하고 단축키가 잘 구성되어있어 라벨링 작업이 상당히 편리해집니다.

기본 단축키 및 마우스 동작

[키보드 상단 숫자키] `부터 0번까지 라벨링 인덱스 변경
[스페이스바 및 마우스 휠] : 현재 이미지 라벨 저장 후 다음 이미지로 이동
[객체의 경계 상자 내부에서 마우스 우측 버튼] : 객체 삭제

라벨링 업무가 쉽다고 빠르게만 하시지 말고, 중간 중간 저장이 잘 되는지, 놓친 이미지는 없는지 꼭 꼭 확인하시길 바랍니다.

# 머신러닝 프로젝트 제작 및 상담 / 머신러닝 접목 졸업작품 상담

# 데이터 가공, 수집, 라벨링 작업 / C, 파이썬 프로그램 제작

# email : deepi.contact.us@gmail.com

# site : www.deep-i.net

[Python] PyQt5 리소스 파일 Import error 해결 방법 "No module named 'icon_rc'"

주식회사 딥아이 — Tue, 1 Dec 2020 12:38:07 +0900

파이썬에서 GUI 작업으로 활용되는 QT에서는 리소스 파일을 통해 이미지 파일을 관리할 수 있습니다. 리소스 파일 qrc을 생성하고 py로 변환하여 메인 코드에 import하는 과정으로 조금 복잡합니다. 저는 이상하게도 메인 코드에 변환된 py 확장자의 리소스 파일을 import 하게 되면 종종 해당 파일이 없다고 No module named 'icon_rc' 오류가 떴습니다.

메인 파이썬 프로그램에서는 import가 정상적으로 되지만, QT Designer로 생성한 ui 파일엔 변환된 정보가 없어서 발생하는 문제인것같습니다. 매 작업때마다 산발적으로 발생하는 오류에 지쳐 이제는 초기화 단계에서 함수형태로 코드를 입력해 ui 확장자 내에서 지정된 리소스 파일의 경로를 수정해주고 있습니다.

import glob

# UI 리소스 경로 업데이트 
def uiUpdate():

    # UI 파일이 있는 경로로 지정
    path = glob.glob('./resources/ui/*.ui')
    for ui_path in path:
        ui_ = open(ui_path, 'r', encoding='utf-8')
        lines_ = ui_.readlines()
        ui_.close()
        for ii, i in enumerate(lines_):
            if 'include location' in i:
                lines_[ii] = i.replace('.qrc', '.py')
        
        ui_ = open(ui_path, 'w', encoding='utf-8')
        [ui_.write(i) for i in lines_]
        ui_.close()
        print('{} update'.format(ui_path))

그때 그때 바로 적용하기 위해 대충 만들다보니 지저분하지만, 저와 같이 리소스 파일 import 에러가 발생하시는 분들은 한번 적용해보시길 바랍니다.

# Jetson 시리즈 응용 임베디드 시스템 제작

# 머신러닝 프로젝트 제작 및 상담 / 머신러닝 접목 졸업작품 상담

# email : deepi.contact.us@gmail.com

# site : www.deep-i.net

[Matlab] 매트랩에서 GIF 이미지(애니메이션) 파일 만들기

주식회사 딥아이 — Sun, 29 Nov 2020 19:05:08 +0900

이번 포스팅은 매트랩에서 동적 이미지 GIF 파일을 생성하는 방법을 소개하겠습니다. 매트랩에서 Figure 창을 스캔해서 저장하는 방식이며 함수 형태로 저장해두면, 그때그때 세미나나 평가 결과 등의 첨부자료로 쉽게 사용하실 수 있습니다.

0. 선행 예제

plot, drawnow, cla 등과 같이 figure를 화면에 띄우는 매트랩 기본함수가 익숙하시지 않다면 이전 포스팅을 참고하셔도 좋을 것 같습니다.

deep-eye.tistory.com/8?category=401244

[Matlab] 매트랩을 이용한 실시간 그래프 그리기

매트랩은 다양한 분야에서 분석하거 설계하는데 활용되고 있습니다. 직관적으로 데이터를 확인할 수 있어 데이터분석 입문으로 시작해도 좋다 생각합니다. 특히, 논문에 사용될 그래프를 도시

deep-eye.tistory.com

1. 매트랩 코드

% *********************************************
% GIF_IMAGE_GENERATER_2D
% Deep.I Inc.
% https://deep-eye.tistory.com
% deepi.contact.us@gmail.com
% *********************************************

filename = 'test.gif';  % 저장될 gif 파일 이름
figure(1);                      % figure 생성

% 프레임 수
for i = 1:30             
    
    cla
 
    % imshow() 
    
    drawnow 
    
    % figure에서의 frame을 가져욤
    frame = getframe(1); 
    % 가져온 frame을 image로 변화시킴
    img = frame2im(frame); 
    % index화된 이미지로 변화시킴
    [imind cm] = rgb2ind(img,256); 

    if i == 1
        %% n 회 반복 + 1/24초의 딜레이를 가지는 gif 생성. 무한 반복은 inf로 함
        imwrite(imind,cm,filename,'gif','Loopcount',1,'DelayTime',1/24);                
    else
        %% 똑같은 파일에 추가를 할 것이므로 append로 함
        imwrite(imind,cm,filename,'gif','WriteMode','append','DelayTime',1/24); 
    end
    
end

핵심은 1. figure를 사전에 지정해주는 것과 imshow()나 plot() 함수 이후 figure 창을 이미지로 전 처리하는 과정입니다. figure를 그대로 저장하다 보니 코드가 진행 중일 때 창을 변형시키면 gif에도 반영되는 것 같습니다. 보통 저는 gif로 변환된 파일을 꿀캠 같은 gif 편집 툴을 활용해서 속도와 크기 등을 그림 1과 같이 2차적으로 편집하곤 합니다.

그림 1. 매트랩으로 생성된 gif 파일 (SOM 클러스터링)

# Jetson 시리즈 응용 임베디드 머신러닝 시스템 제작

# 머신러닝 프로젝트 제작, 상담 및 컨설팅 / 머신러닝 접목 졸업작품 컨설팅

# email : deepi.contact.us@gmail.com

# site : www.deep-i.net

[Python] 파이썬을 이용한 다층신경망 (Multi-Layer Perceptron: MLP) 구현하기 (XOR 문제)

주식회사 딥아이 — Sat, 28 Nov 2020 00:55:00 +0900

1986년 역전파 알고리즘 (Backpropagation)의 개념이 도입되면서 Machine Learning이 다시 주목받게 되었습니다. 기존 단층 신경망으로는 해결할 수 없었던 비선형 문제 해결이 가능한 다층 신경망은 현재 응용되고 있는 CNN(Convolutional Neural Networks)의 기반이 되고 있습니다. 이번 포스팅에서는 파이썬을 이용해서 다층 신경망을 구현해 보록 하겠습니다.

그림 1. 퍼셉트론의 기본 구조

매트랩을 이용한 다층신경망 구현 포스팅과 동일한 메커니즘으로 설계했습니다. 매트랩 코드는 이전 포스팅을 참고해 주시길 바랍니다.

deep-eye.tistory.com/16

[Matlab] 매트랩을 이용한 다층신경망 (Multi-Layer Perceptron: MLP) 구현하기 (XOR 문제)

1986년 역전파 알고리즘 (Backpropagation)의 개념이 도입되면서 Machine Learning이 다시 주목받게 되었습니다. 기존 단층 신경망으로는 해결할 수 없었던 비선형 문제 해결이 가능한 다층 신경망은 현재

deep-eye.tistory.com

1. 샘플 코드 다운로드

git clone https://github.com/DEEPI-LAB/python-simple-multi-layer-neural-network-implementation.git

github.com/DEEPI-LAB/python-simple-multi-layer-neural-network-implementation

DEEPI-LAB/python-simple-multi-layer-neural-network-implementation

Python implementation of multi-layer perceptron (MLP) neural networks using only numpy and matplotlib - DEEPI-LAB/python-simple-multi-layer-neural-network-implementation

github.com

2. 학습 데이터 생성 및 파라미터 초기화

import numpy as np
from matplotlib import pyplot as plt

# train data (XOR Problem)
x = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([0,1,1,0])

# Intialization

# input - hidden layer
w1 = np.random.randn(2,2)
b1 = np.random.randn(1,2)

# hidden - output layer
w2 = np.random.randn(1,2)
b2 = np.random.randn(1)

# epoch
ep = 20000

# learning rate
lr = 1
mse = []

[입력 - 은닉 - 출력]으로 구성된 MLP의 기본 구조를 사용했습니다. w1과 b1은 입력층과 은닉층의 가중치와 바이어스, w2과 b2는 은닉층과 출력층의 가중치와 바이어스입니다. 초기값은 모두 가우시안 랜덤 값으로 초기화했습니다.

3. 신경망 순전파 출력 단계

# Neural Networks 2-2-1
for i in range(ep):
    
    E  = np.array([])
    result = np.array([])
    
    for j in range(len(x)):
        Ha = np.array([])
        
        # feedforward
        # input - hidden layer
        for k in range(len(w1)):
            Ha = np.append(Ha,1 / (1 + np.exp(-(np.sum(x[j] * w1[k]) + b1[0][k]))))
        
        # hideen - output layer
        Hb = 1 / (1 + np.exp(-(np.sum(Ha * w2) + b2)))
        
        # error
        E = np.append(E,y[j] - Hb)
        result = np.append(result,Hb)

시그모이드 활성화 함수를 사용했습니다. 2차원 데이터 입력 - 2개의 은닉층 노드로 구성하여 별도의 행렬 연산 과정이 필요 없지만, 은닉층의 노드 수나 입력 데이터의 차원을 다르게 설계하면 이에 맞춰 변형해야 합니다.

4. 신경망 역전파 업데이트 단계

        # back-propagation
        # output - hidden layer
        alpha_2 = E[j] * Hb * (1-Hb)
        
        # hidden - input layer
        alpha_1 = alpha_2 * Ha * (1-Ha) * w2
        
        # update
        w2 = w2 + (lr * alpha_2 * Ha)
        b2 = b2 + lr * alpha_2
        
        w1 = w1 + np.ones((2,2)) * lr * alpha_1 * x[j]
        b1 = b1 +  lr * alpha_1

신경망 학습 알고리즘의 핵심, 역전파 단계입니다. 자세한 설명은 생략하겠습니다. 추후 머신러닝 관련 포스팅을 통해 자세히 다루어보도록 하겠습니다. 자료와 코드는 쌓여있는데 이걸 정리하기가 쉽지 않네요 ㅠ

5. 최종 코드

# -*- coding: utf-8 -*-
"""
Neural Network Multi-Layer Perseptron (XOR Problem)
@author: Deep.I Inc. @Jongwon Kim
Revision date: 2020-11-28
See here for more information :
    https://deep-eye.tistory.com/16
    https://deep-i.net
"""

import numpy as np
from matplotlib import pyplot as plt

# train data (XOR Problem)
x = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([0,1,1,0])

# Intialization

# input - hidden layer
w1 = np.random.randn(2,2)
b1 = np.random.randn(1,2)

# hidden - output layer
w2 = np.random.randn(1,2)
b2 = np.random.randn(1)

# epoch
ep = 20000
# learning rate
lr = 1
mse = []

# Neural Networks 2-2-1
for i in range(ep):
    
    E  = np.array([])
    result = np.array([])
    
    for j in range(len(x)):
        Ha = np.array([])
        
        # feedforward
        # input - hidden layer
        for k in range(len(w1)):
            Ha = np.append(Ha,1 / (1 + np.exp(-(np.sum(x[j] * w1[k]) + b1[0][k]))))
        
        # hideen - output layer
        Hb = 1 / (1 + np.exp(-(np.sum(Ha * w2) + b2)))
        
        # error
        E = np.append(E,y[j] - Hb)
        result = np.append(result,Hb)
        
        # back-propagation
        # output - hidden layer
        alpha_2 = E[j] * Hb * (1-Hb)
        
        # hidden - input layer
        alpha_1 = alpha_2 * Ha * (1-Ha) * w2
        
        # update
        w2 = w2 + (lr * alpha_2 * Ha)
        b2 = b2 + lr * alpha_2
        
        w1 = w1 + np.ones((2,2)) * lr * alpha_1 * x[j]
        b1 = b1 +  lr * alpha_1
        
    print('EPOCH : %05d MSE : %04f RESULTS : 0 0 => %04f 0 1 => %04f 1 0 => %04f 1 1 => %04f'
          %(i,np.mean(E**2),result[0],result[1],result[2],result[3]))
    
    mse.append(np.mean(E**2))

    # plot graph
    
    # if i%100 == 0:
    #     plt.xlabel('EPOCH')
    #     plt.ylabel('MSE')
    #     plt.title('MLP TEST')
    #     plt.plot(mse)
    #     plt.show()

역전파와 시그모이드 함수 이외 다른 기술적인 테크닉이 전혀 없는 코드입니다. 따라서 단순한 XOR 역시 초기값에 따라 학습이 되지 않는 경우도 많이 발생합니다. 모멘텀이나, 적응형 학습률 등의 다양한 방법으로 응용해보시길 바랍니다.

# 머신러닝 프로젝트 제작, 상담 및 컨설팅 / 머신러닝 접목 졸업작품 컨설팅

# 데이터 가공, 수집, 라벨링 작업 / C, 파이썬 프로그램 제작

# email : deepi.contact.us@gmail.com

# site : www.deep-i.net

[MATLAB] 클러스터링 (군집화) 기법 구현을 위한 기본 2D 데이터셋 모음

주식회사 딥아이 — Thu, 26 Nov 2020 17:45:34 +0900

클러스터링은 사용되는 분야와 데이터 특징에 따라 정말 다양하게 응용되고 있습니다. 하지만, 기본적인 '군집'의 메커니즘은 모두 동일하기 때문에 논문에서 아이디어를 제안하면서 사용되는 데이터는 그림 1과 같이 2차원 데이터입니다. 이번 포스팅에서는 Application 단계 이전에 클러스터링 연습이나 구현 또는 제안하려는 기법의 평가를 위해 사용되는 2차원 데이터 몇 가지를 소개하겠습니다.

그림 1. 성능평가에 활용되는 2D 데이터

1. 데이터 다운로드

git clone https://github.com/DEEPI-LAB/clustering-dataset.git

데이터가 많다보니 정리가 어려워 깃허브에 올렸습니다. 링크를 통해서도 받으실 수 있습니다.

github.com/DEEPI-LAB/clustering-dataset

DEEPI-LAB/clustering-dataset

2d spatial dataset for clustering evaluation. Contribute to DEEPI-LAB/clustering-dataset development by creating an account on GitHub.

github.com

2. 데이터 확인

그림 2. 0번 데이터 좌) 원본 우) k-means 결과

그림 3. 1번 데이터 좌) 원본 우) k-means 결과

2개의 군집을 가지는 0번 데이터는 K-Means로도 쉽게 군집됩니다. 하지만 군집 모양과 크기가 다른 1번 데이터 군집은 실패하였습니다. 구현을 위한 k-Means 알고리즘은 이전 포스팅을 참고하시면 됩니다.

deep-eye.tistory.com/24

[Matlab] K-Means Clustering (K-평균 군집화) 알고리즘 구현하기

1967년 처음 제안된 K-Means 클러스터링 (K-평균 군집화)은 군집화 알고리즘의 시작을 알린 데이터 마이닝 기법입니다. 파티션을 분리하는 기법 (Partitioning) 으로 분류되는 K-means 는 사전에 부여된 클

deep-eye.tistory.com

그림 4. 2번 데이터 좌) 원본 우) k-means 결과

그림 5. 3번 데이터 좌) 원본 우) k-means 결과

2번 데이터는 0번과 비교하여 동일하지만, 겹침 문제 (joint problem)이 일부 존재합니다. 3번 데이터는 학습 초기값에 따라 실패할 수도 있는 데이터입니다.

그림 6. 4번 데이터 좌) 원본 우) k-means 결과

그림 7. 5번 데이터 좌) 원본 우) k-means 결과

그림 8. 6번 데이터 좌) 원본 우) k-means 결과

갑자기 군집 난이도가 상승했습니다. 4-6번 데이터는 클러스터의 밀도가 서로 다르거나, 잡음이 추가되었습니다. 또한, 원형이나 사각형 형태의 군집이 아닌 비선형성을 가지는 데이터 집합입니다. 이외에 7 - 9번 데이터는 라벨 정보도 포함된 데이터이며 실제 성능평가로도 활용되고 있습니다. 논문에서 클러스터링 알고리즘을 새롭게 제안한다면 한 번 시도해보시길 바랍니다.

# Jetson 시리즈 응용 임베디드 머신러닝 시스템 제작

# 머신러닝 프로젝트 제작, 상담 및 컨설팅 / 머신러닝 접목 졸업작품 컨설팅

# 데이터 가공, 수집, 라벨링 작업 / C, 파이썬 프로그램 제작

# email : deepi.contact.us@gmail.com

# site : www.deep-i.net

[Python] PyTicToc 파이썬에서 경과 시간 간편하게 측정하기

주식회사 딥아이 — Wed, 25 Nov 2020 23:14:44 +0900

프로그래밍을 하다 보면 여러 가지 이유로 알고리즘 연산 시간을 측정하게 되는 경우가 발생하게 됩니다. 파이썬에서는 보통 time이나 timeit 모듈을 통해 측정하고 있습니다. 복잡한 코딩을 요구하지는 않지만, 좀 더 쉽고 빠르게 경과시간을 측정할 수 있는 PyTicToc를 소개합니다.

PyTicToc은 매트랩 기본 함수로 제공되는 tic toc 시간 측정과 매우 유사합니다. 우선 pip를 통해 설치를 해줍니다.

pip install pytictoc

1. 모듈 불러오기

from pytictoc import TicToc

# TicToc 클래스 생성
t = TicToc()

TicToc을 import 한 다음, 클래스를 생성해주면 모든 준비가 완료됩니다.

2. 시간 연산

 t.tic() # 시작 시간
 
 # 알고리즘 연산
 
 t.toc() # 종료 시간
 
 >> Elapsed time is 1.323425 seconds.

측정해야되는 알고리즘 시작과 끝부분에 tic toc을 걸어주시면 됩니다.

3. 변수로 저장

s = t.tocvalue()

>> s : 2.15483

tocvalue()를 통해 변수로 저장할 수 있습니다.

# Jetson 시리즈 응용 임베디드 머신러닝 시스템 제작

# 머신러닝 프로젝트 제작, 상담 및 컨설팅 / 머신러닝 접목 졸업작품 컨설팅

# 데이터 가공, 수집, 라벨링 작업 / C, 파이썬 프로그램 제작

# email : deepi.contact.us@gmail.com

# site : www.deep-i.net

[Matlab] K-Means Clustering (K-평균 군집화) 알고리즘 구현하기

주식회사 딥아이 — Tue, 24 Nov 2020 14:42:55 +0900

1967년 처음 제안된 K-Means 클러스터링 (K-평균 군집화)은 군집화 알고리즘의 시작을 알린 데이터 마이닝 기법입니다. 파티션을 분리하는 기법 (Partitioning) 으로 분류되는 K-means 는 사전에 부여된 클러스터의 개수와 개체 간의 거리를 기반으로 전체 클러스터의 중심과의 거리를 최소화 하며 군집을 수행합니다. 이번 포스팅에서는 간단하게 K-Means 알고리즘을 살펴본 뒤, 매트랩에서 직접 알고리즘을 구현해보도록 하겠습니다.

1. K-Means 알고리즘의 목표

$n$ 개의 데이터를 가지는 $d$ 차원 데이터 집합 $X=(x_1,x_2,...,x_n)$가 있습니다. 쉽게 예를 들기 위해, $d=2$를 가지는 2차원 공간 데이터로 가정하게되면 그림 1과 같이 표현이 가능합니다.

그림 1. K-Means 알고리즘 예시

데이터 집합 $X$가 주어졌을때, K-Means는 사전에 지정된 클러스터 개수 $k$ 만큼 집합을 만들고 각 집합에 포함된 데이터들끼리의 응집도를 최대로 하는 방식으로 군집을 수행합니다. 여기서 클러스터 개수는 전체 데이터의 개수 $n$ 보다 작게 설정되어야 하며, 전체 클러스터의 집합 $C=(c_1,c_2,...,c_k)$로 표현됩니다.

1. $n$개로 구성된 $d$ 차원의 데이터 집합 $X=(x_1,x_2,...,x_n)$

2. $k(<=n)$개의 지정된 클러스터 개수

3. $C=(c_1,c_2,...,c_k)$로 표현되는 전체 클러스터 집합

이때, 집합 $C$ 군집을 대표하는 중심(Centroid)축을 $u_k$로 정의합니다. 중심축 $u_k$가 K-Measn의 군집 방식 '응집도를 최대로' 하는 방향으로 학습하며 최적화됩니다. 이는 식 1과 같습니다.

$$\underset{s}{\operatorname{argmin}} \sum_{i=1}^{k}\sum_{x\in{C_i}}||x-u_i||^2$$

응집도의 최대화하는 것은 공간적으로 같은 군집끼리의 거리를 최소화하는것이 됩니다. 즉, K-Means 알고리즘의 핵심은 전체 군집 개수 $k$까지 집합 $C_i$에 포함된 데이터 $x$와 $C_i$를 대표하는 중심축 $u_i$의 거리를 최소화하는 문제입니다.

2. K-Means 알고리즘

1. $u_k$ 초기화 : 초기 Centroid 값을 선정하기 위해 집합 $X$ 에서 임의로 값을 선정합니다.

2. 응집도 연산 : 모든 데이터에 대하여 초기화된 $u_k$와 거리를 구합니다. 이후, 가장 인접한 Centroid 값을 가지는 클러스터 집합 $C$의 원소로 입력합니다.

3. 군집 업데이트 : 모든 데이터가 $C$의 원소로 선택되었다면, 이를 바탕으로 $C$의 중심축 $u_k$를 수정합니다. 일반적인 K-Means는 이 과정에서 집합 내 원소의 평균값으로 갱신됩니다.

4. 원하는 학습 횟수 또는 목적 함수가 최적화될때까지 2~3의 과정을 반복합니다.

3. Matlab 코드

0. 샘플 코드 다운로드

git clone https://github.com/DEEPI-LAB/k-means-implementation-in-matlab.git

매트랩 코드와 2차원 데이터 샘플을 포함하고 있는 예제입니다. 아래 경로를 통해서도 직접 다운로드가 가능합니다.

github.com/DEEPI-LAB/k-means-implementation-in-matlab

DEEPI-LAB/k-means-implementation-in-matlab

Contribute to DEEPI-LAB/k-means-implementation-in-matlab development by creating an account on GitHub.

github.com

1. 학습 파라미터 초기화

load corner.mat

# 2차원 공간 데이터
X = X;
# 클러스터 개수
k = 4;                       
# 클러스터 위치 초기화 인덱스 선정
rand = randperm(length(X),k);
# 초기 Centroid 값
u = X(rand ,:);
# 학습 횟수
z = 10;

가장 기본적인 클러스터 데이터 중 하나인 2차원 공간 데이터를 함께 첨부하였습니다. K-Means 알고리즘 초기화 단계입니다. $u_k$를 초기화하기 위해 임의로 입력 데이터 $X$의 원소를 선정합니다.

2. 응집도 연산

# 학습 시작
for z=1:10
    # 최대값 저장메모리 할당
    C = cell(k,1);
    for j=1:length(X)
        
        # 거리 구하기
        for i =1:k
            dist(i,1) = norm(X(j,:)-u(i,:));
        end
        # 중심점과 가장 유사도가 높은 데이터를 중심점 클러스터로 할당
        arg = find(dist==min(dist));
        C{arg}(end+1,:) = X(j,:);
    end

학습이 반복될때마다 클러스터 집합 $C$가 갱신될 수 있도록 초기화해줍니다. 이후, 모든 데이터 $X$를 스캔하면서 $c_k$와의 거리를 구한 뒤, 가장 인접함 Centorid 값을 가지는 집합 $C$의 원소로 설정합니다.

3. 업데이트

 for i = 1:k
 
 	# 군집된 클러스터 원소
        cluster = C{i};
 	# 전체 평균값 
 	cluster = sum(cluster) ./ sum(cluster~=0,1);
        try
            u(i,:) = cluster;
        end
    end
end

한번 반복이 완료되면, 를 바탕으로 $C$의 중심축 $u_k$를 원소의 평균을 통해 수정하게 됩니다.

4. 최종코드

# *********************************************
# Unsupervised Learning - K-Means algorithm
# Deep.I Inc.
# *********************************************

load corner.mat

# 2차원 공간 데이터
X = X;
# 클러스터 개수
k = 4;                       
# 클러스터 위치 초기화 인덱스 선정
rand = randperm(length(X),k);
# 초기 Centroid 값
u = X(rand ,:);
# 학습 횟수
z = 10;

# 학습 시작
for z=1:10
    # 최대값 저장메모리 할당
    C = cell(k,1);
    for j=1:length(X)
        # 거리 구하기
        for i =1:k
            dist(i,1) = norm(X(j,:)-u(i,:));
        end
        # 중심점과 가장 유사도가 높은 데이터를 중심점 클러스터로 할당
        arg = find(dist==min(dist));
        C{arg}(end+1,:) = X(j,:);
    end
   
    for i = 1:k
        cluster = C{i};
        cluster = sum(cluster) ./ sum(cluster~=0,1);
        try
            u(i,:) = cluster;
        end
    end
    
    # 실시간으로 군집 결과 확인하기
    cla; hold on;
    for i = 1: k
        cluster = C{i};
        try
            scatter(cluster(:,1),cluster(:,2),'.')
            scatter(u(:,1),u(:,2),'*r','LineWidth',5)
        end
    end
    pause(2)
    
end

4. 결론

그림 2. 알고리즘 구현 화면

사실 K-Means는 비선형 데이터 군집이나, 군집의 개수를 알지 못하는 경우에는 적용할 수가 없다는 치명적인 단점이 존재합니다. 이밖에도 군집 밀도나 겹침 등의 문제에도 낮은 강인성을 보이고 있죠. 첨부된 군집 데이터 모두 K-Means로는 쉽게 군집되지 않습니다. 이를 해결하기 위해 현대의 클러스터링 기법은 밀도를 이용하거나 그래프 모델, 신경망 등의 다양한 알고리즘으로 군집 문제를 접근하고 있습니다.

# 머신러닝 프로젝트 제작, 상담 및 컨설팅 / 머신러닝 접목 졸업작품 컨설팅

# 데이터 가공, 수집, 라벨링 작업 / C, 파이썬 프로그램 제작

# email : deepi.contact.us@gmail.com

# site : www.deep-i.net

[Python] PyQt 에서 로딩(애니메이션) 화면 구현하기

주식회사 딥아이 — Mon, 23 Nov 2020 14:25:24 +0900

GUI 기반 프로그램에서는 직관적이고 편리한 UI/UX 구성도 중요하지만, 프로그램에서 특정 액션이 발생할 때 사용자에게 지금 어떤 '상황'인지 알려주는 상호작용 역시 매우 중요합니다. 예를 들어, 버튼 클릭은 된건지, 접속은 된건지 현재 액션에 대한 반응으로 사용자가 느낄수 있어야 합니다. 이번 포스팅에서는 PyQt에서 간단하게 이벤트가 입력되었을때 로딩중이다라는것을 보여 줄 수 있는 창을 한번 구현해보겠습니다.

그림 1. 로딩 이미지

1. 로딩 이미지 파일 (GIF, SVG, APNG) 만들기

동적 로딩화면 구현을 위해서는 GIF, SVG, APNG 등과 같이 애니메이션 효과가 가능한 파일이 필요합니다. 저는 아래 사이트에서 무료로 제작 가능한 로딩 이미지를 받아서 사용했습니다. 이번 포스팅에서는 GIF를 활용해보겠습니다.

loading.io/

loading.io - Your SVG + GIF + PNG Ajax Loading Icons and Animation Generator

Build Your Ajax Loading Icons, Animated Text and More with SVG / CSS / GIF / PNG !

loading.io

2. MainWindow 클래스 생성

import sys

from PyQt5 import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import*
from PyQt5 import uic

FROM_CLASS_MainWindow = uic.loadUiType("mainwindow.ui")[0]

class MainWindow(QMainWindow,FROM_CLASS_MainWindow):    

    def __init__(self):
        super().__init__()
        
        # UI 파일 로드
        self.setupUi(self) 
        self.show()
        
        # 버튼 클릭 매서드
        self.button.clicked.connect(self.loading)
        
if __name__ == '__main__':
    app = QApplication(sys.argv)
    ShowApp = MainWindow()
    sys.exit(app.exec_())

첨부된 UI파일을 이용하시거나 진행중인 프로젝트에서 메인 클래스를 불러와줍니다. 저는 QT Designer를 통해 UI를 만든다음, uic.loadUiType 함수로 불러오는것을 선호하고 있습니다.

3. Loading 클래스 생성

FROM_CLASS_Loading = uic.loadUiType("load.ui")[0]

class loading(QWidget,FROM_CLASS_Loading):
    
    def __init__(self,parent):
        super(loading,self).__init__(parent)    
        self.setupUi(self) 
        self.center()
        self.show()
        
        # 동적 이미지 추가
        self.movie = QMovie('loading.gif', QByteArray(), self)
        self.movie.setCacheMode(QMovie.CacheAll)
        # QLabel에 동적 이미지 삽입
        self.label.setMovie(self.movie)
        self.movie.start()
        
        # 윈도우 해더 숨기기
        self.setWindowFlags(Qt.FramelessWindowHint)   
    
    # 위젯 정중앙 위치
    def center(self):
        size=self.size()
        ph = self.parent().geometry().height()
        pw = self.parent().geometry().width()
        self.move(int(pw/2 - size.width()/2), int(ph/2 - size.height()/2))

동일한 방식으로 로딩화면을 구현할 위젯 클래스를 생성해줍니다. center 함수는 위젯이 생성되엇을때 현재 실행중인 프로그램 윈도우의 정중앙에 배열해줍니다. 이후 버튼 클릭 매서트를 메인 클래스에 추가하여 Loading 클래스를 생성할 수 있게 합니다.

3-1. Loading gif 실행

        # 동적 이미지 추가
        self.movie = QMovie('loading.gif', QByteArray(), self)
        self.movie.setCacheMode(QMovie.CacheAll)
        # QLabel에 동적 이미지 삽입
        self.label.setMovie(self.movie)
        self.movie.start()

QMovie를 통해 gif 이미지 파일을 동적으로 재생되도록 해줍니다. SVG 파일의 경우, 별도의 SVG 위젯과 직접 연결하여 사용하면 됩니다. 그리고 아직까지 QT에서 APNG 파일은 정식적으로 지원하지는 않는것같습니다. 이미지는 출력되지만 애니매이션 효과는 발생하지않네요.

4. 버튼 클릭 이벤트 함수 생성 (MainWindow)

        # 버튼 클릭 매서드
        self.button.clicked.connect(self.loading)
        
    def loading(self):
        # 로딩중일때 다시 클릭하는 경우
        try: 
            self.loading
            self.loading.deleteLater()
            
        # 처음 클릭하는 경우    
        except:
            self.loading = loading(self)

clicked.connect()를 통해 loading 함수와 연결해줍니다. loading 함수에서는 클래스를 생성해주는 역할만 수행됩니다. 이미 로딩 화면이 실행 중일 경우에는 이를 삭제하여 로딩 화면을 삭제하는 1버튼 2매서트 방식으로 구현하였습니다. deleteLater()은 실행중인 클래스를 현재 함수 종료 이후 삭제해주는 함수입니다.

5. 최종 완성 코드

# -*- coding: utf-8 -*-
"""
Created on Sun Nov  8 13:05:23 2020
@author: DEEP.I Inc.
"""
import sys

from PyQt5 import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import*
from PyQt5 import uic

FROM_CLASS_MainWindow = uic.loadUiType("mainwindow.ui")[0]
FROM_CLASS_Loading = uic.loadUiType("load.ui")[0]

class MainWindow(QMainWindow,FROM_CLASS_MainWindow):    

    def __init__(self):
        super().__init__() 
        self.setupUi(self) 
        self.show()
        
        # 버튼 클릭 매서드
        self.button.clicked.connect(self.loading)
        
    def loading(self):
        # 로딩중일때 다시 클릭하는 경우
        try: 
            self.loading
            self.loading.deleteLater()
            
        # 처음 클릭하는 경우    
        except:
            self.loading = loading(self)
        

#%% Loading Img
class loading(QWidget,FROM_CLASS_Loading):
    
    def __init__(self,parent):
        super(loading,self).__init__(parent)    
        self.setupUi(self) 
        self.center()
        self.show()
        
        # 동적 이미지 추가
        self.movie = QMovie('loading.gif', QByteArray(), self)
        self.movie.setCacheMode(QMovie.CacheAll)
        # QLabel에 동적 이미지 삽입
        self.label.setMovie(self.movie)
        self.movie.start()
        # 윈도우 해더 숨기기
        self.setWindowFlags(Qt.FramelessWindowHint)
    
    # 위젯 정중앙 위치
    def center(self):
        size=self.size()
        ph = self.parent().geometry().height()
        pw = self.parent().geometry().width()
        self.move(int(pw/2 - size.width()/2), int(ph/2 - size.height()/2))

        
if __name__ == '__main__':
    app = QApplication(sys.argv)
    ShowApp = MainWindow()
    sys.exit(app.exec_())

그림 2. 구현 화면

Loading.zip

0.06MB

# Jetson 시리즈 응용 임베디드 머신러닝 시스템 제작

# 머신러닝 프로젝트 제작, 상담 및 컨설팅 / 머신러닝 접목 졸업작품 컨설팅

# 데이터 가공, 수집, 라벨링 작업 / C, 파이썬 프로그램 제작

# email : deepi.contact.us@gmail.com

# site : www.deep-i.net

[Jetson] Jetson Nano, TX2, Xavier에 시스템 모니터링 및 컨트롤 패키지 Jetson stats 설치하기

주식회사 딥아이 — Sun, 22 Nov 2020 13:17:09 +0900

소형 임베디드 AI 시스템의 혁신적인 Jetson 시리즈는 리눅스를 기반으로 구동되지만, aarch64 아키텍터로 설계되어 일부 패키지를 이용하는데 불편한 점이 있었습니다. 제가 처음 Jetson으로 프로젝트를 진행했을 땐 간단한 시스템 컨트롤 조차 어려웠는데, 통합적으로 기본적인 jetson 모니터링과 컨트롤이 가능한 기가 막힌 패키지 Jetson Stats가 나왔습니다. 다시 한번 개발자에게 찬사를 보냅니다.

github.com/rbonghi/jetson_stats

rbonghi/jetson_stats

Simple package to monitoring and control your NVIDIA Jetson [Xavier NX, Nano, AGX Xavier, TX1, TX2] - rbonghi/jetson_stats

github.com

Jeston-states는 Jetson 시리즈 [Xavier NX, Nano, AGX Xavier, TX1, TX2] 시스템 모니터링과 컨트롤 패키지라고 개발자는 설명합니다. 직관적인 구성으로 저는 Jetson setup 이후 항상 이 패키지를 설치해서 관리하고 있습니다.

Jetson-stats 설치

sudo -H pip install -U jetson-stats

설치 이후, 재부팅을 진행해주시면 설치가 완료됩니다. 기본적으로 5개의 패키지를 포함하고 있습니다.

jtop - 시스템 모니터링 유틸리티
jetson_config - 시스템 기본 config 파일 설정
jetson_releas - 시스템 정보
jetson_swap - swap 메모리 설정
jetson variables - 환경변수 설정

우리에게 필요한건 jtop 입니다. 이거 하나면 전반적인 시스템 컨트롤과 모니터링이 가능합니다. 터미널을 열고, jtop 명령어로 실행해주면 됩니다. 실시간 시스템 모니터링을 비롯하여 메모리 swap도 쉽게 가능합니다. 또한 기존, jetson_clocks 명령어로 제어하였던 Fan 역시 쉽게 제어할 수 있습니다.

그림 1. 실시간 시스템 모니터링

그림 2. 메모리 할당량 확인 및 swap 메모리 설정

그림 3. 잭슨 개발자 키트에 포함된 Fan 제어

그림 4. Jetson 시스템 정보

Jetson-stats 구동 확인

Jetson Xavier를 이용한 지능형 영상 분석 프로젝트에서 테스트 결과, 시스템 모니터링이 정상적으로 작동되는 것을 확인하였습니다. 여담이지만 Jetson Xaiver는 정말 powerful 한 임베디드 프로세서인 것 같습니다. YOLO V4 - 416 모델이 평균 20 ~ 30 FPS으로 구현되네요... 소형 머신러닝 임베디드 시스템 제작에 정말 적합한 것 같습니다.

그림 5. jetson-stats 모니터링

# Jetson 시리즈 응용 임베디드 머신러닝 시스템 제작

# 머신러닝 프로젝트 제작, 상담 및 컨설팅 / 머신러닝 접목 졸업작품 컨설팅

# 데이터 가공, 수집, 라벨링 작업 / C, 파이썬 프로그램 제작

# email : deepi.contact.us@gmail.com

# site : www.deep-i.net