코드 한줄

Tensorflow Serving vs Flask REST API

기루광 — Tue, 28 Dec 2021 01:08:32 +0900

Tensorflow serving 을 이용하기 전에는 flask 를 이용하여 REST API 를 만들어 microservice를 진행하는 것을 당연하게 생각했었습니다. python 의 overhead 줄이기 위해 C++/golang 등 다른 framework 를 써야 된다는 것을 알았지만, 큰 영향이 없겠다 싶어 고민하지 않았던 것 같습니다.

"TensorFlow Serving is a flexible, high-performance serving system for machine learning models, designed for production environments."

https://github.com/tensorflow/serving

Tensorflow serving은 유연하고, 고성능 서빙 시스템으로 프로덕션 환경에 맞게 디자인 되었다고 되어있는데 그럼 flask REST API 와 속도차이가 얼마나 나는지 궁금해서 비교해 보았습니다.

우선 Tensorflow Serving 경우 REST API 방식과 gRPC 방식 2가지를 모두 지원하고 있습니다. (gRPC 내용은 추가 필요)

1. Flask REST API

2. REST API [ Tensorflow Serving ]

3. gRPC API [Tensorflow Serving]

# 우선 심플한 CNN toy 모델을 학습해서 모델을 저장해놓고 이를 비교 검증을 진행 하도록 하겠습니다.

간단히 Colab 을 통해서 학습을 진행하였습니다. 해당 모델 파일을 다운로드 받아 압축을 푼 후 적당한 위치에 저장합니다.

(아래는 Colab 실제 코드입니다.)

tf_model_mnist.tar.gz

0.55MB

## Toy Model CNN

import numpy as np
import tensorflow as tf
from tensorflow.keras import layers

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train/255.0, x_test/255.0

x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)

class CNN(tf.keras.Model):
    def __init__(self):
        super(CNN, self).__init__()
        # 28,28,1
        self.layer1 = tf.keras.Sequential(
            [layers.Conv2D(32, kernel_size=3, 
                           padding='same',activation='relu'),
             layers.MaxPool2D(pool_size=(2,2), strides=2, padding='same')])
        # 14,14,32
        self.layer2 = tf.keras.Sequential(
            [layers.Conv2D(64, kernel_size=3, 
                           padding='same',activation='relu'),
             layers.MaxPool2D(pool_size=(2,2), strides=2, padding='same')])
        # 7,7,64
        self.flatten = layers.Flatten()
        self.fc = layers.Dense(10)

    def call(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = self.flatten(out)
        return self.fc(out)
        
## * from_logits=True - softmax 수행하기 전의 값을 사용 ##
criterion = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
optimizer = tf.keras.optimizers.Adam()
tf_model = CNN()
tf_model.compile(loss=criterion, optimizer=optimizer)

train_epochs =20
batch_size = 1024
model_path = 'tf_cnn_model'
version = '1'
save_path = f'{model_path}/{version}'

tf_model.fit(x_train, y_train, batch_size=batch_size, epochs=train_epochs)

pred_y = tf_model.predict(x_test, batch_size=batch_size)
accuracy = np.sum(np.argmax(pred_y, axis=1) == y_test)/len(y_test)
print(f'accuracy : {accuracy:>.4f}')

tf.keras.models.save_model(tf_model, save_path)
#!tar -zcvf tf_cnn_model.tar.gz tf_cnn_model

다음 해야 할일은 tenserflow serving 을 실행할 차례인데, docker 로 이미지를 다운로드 받아 docker 실행 시 몇가지 설정을 추가로 해주셔야 합니다.

기본적인 docker 사용법 및 옵션은 아래 사이트를 보시면 친절하고 자세히 설명되어 있습니다.

초보를 위한 도커 안내서 - 설치하고 컨테이너 실행하기

docker run [OPTIONS] IMAGE[:TAG|@DIGEST] [COMMAND] [ARG...]

다음은 자주 사용하는 옵션들입니다.

옵션설명

-d	detached mode 흔히 말하는 백그라운드 모드
-p	호스트와 컨테이너의 포트를 연결 (포워딩)
-v	호스트와 컨테이너의 디렉토리를 연결 (마운트)
-e	컨테이너 내에서 사용할 환경변수 설정
–name	컨테이너 이름 설정
–rm	프로세스 종료시 컨테이너 자동 제거
-it	-i와 -t를 동시에 사용한 것으로 터미널 입력을 위한 옵션
–link	컨테이너 연결 [컨테이너명:별칭]

# Download the TensorFlow Serving Docker image and repo
docker pull tensorflow/serving

# Run Tensorflow Serving(docker)
docker run -t --rm -p 8500:8500 -p 8501:8501 \
    -v "/home/roadcom/workspace/models/tf_cnn_model:/models/mnist_model" \
    -e MODEL_NAME=mnist_model \
    tensorflow/serving &

결과: gRPC(TF) > REST(TF) >> Flask > Flask+gunicorn 순으로 나타납니다.

Tenserflwo Serving이 왜 중요한지를 보여주는 차이입니다.

실험 방법은 mnist test set 을 동일하게 로딩 후 요청 - 응답 간 10 회 반복 값입니다. 오래된 로컬 컴퓨터라 속도가 빠르지는 않지만, 표준편차가 낮은 것을 보아 비교에는 큰 문제가 없을 것같습니다.

Metric	gRPC (TF)	REST (TF)	Flask	Flask+gunicorn
AVG (s)	0.983	1.624	9.088	9.394
STD (s)	0.011	0.021	0.378	0.348

해당 코드는 아래 github 에 공유드립니다.

https://github.com/elentail/Serving.git

참조 :

초보를 위한 도커 안내서 - 설치하고 컨테이너 실행하기

(https://subicura.com/2017/01/19/docker-guide-for-beginners-2.html)

Buffer overflow 란?

기루광 — Mon, 27 Dec 2021 00:34:32 +0900

Buffer overflow 란, 고정된 메모리 버퍼를 넘어서 접근해야 되지 않을 주소, 메모리 공간까지 넘어가 그 곳의 정보를 수정하거나 덮어쓰게 되는 것입니다. 덮어쓰는 내용을 특정 코드를 실행하도록 덮어 씌우는 공격이 바로 buffer overflow 공격입니다.

먼저 메모리 Stack 에 대한 내용을 알아야 될 것 같아 간단히 그림을 그려봅니다.

Process Memory

heap
malloc, new 할당 동적 데이터
stack
전역 변수, 콜Stack(함수 파라미터 / 리턴 어드레스)
data(global variabels)
- uninitialized data
- initialized data
code(or text)
프로그램 기계어 코드가 올라가는 영역

우리가 실행하는 Process 의 메모리 구조를 보면 1개의 Process는 1개의 stack 과 1개 이상의 heap을 가질 수 있습니다. BOF(Buffer Over Flow) 공격은 여기에서 stack 영역 중 Return Address 를 변경하여 메모리 내 특정 코드가 실행되도록 하는 공격 방법입니다.

&lt;메모리 구조&gt;

실제 buffer overflow를 하기위해서는 scanf, strcpy, strcat 등 메모리를 조작하는 모든 함수를 통해서 가능합니다. 결론 부터 말씀드리면 *_s 함수를 통하면 buffer over flow 가 일어날 수 있는 일들을 원천 차단할 수 있습니다.

코드를 예로 들어 자세히 설명 드리면 sniper() 함수를 전혀 실행될 수 없지만, 이를 실행 할 수있도록 메모리를 변조해보도록 하겠습니다. 아래 코드는 단순히 subroutine 을 실행하고 subroutine 안에서 scanf 를 통해 입력받고 종료되는 코드입니다.

#include <stdio.h>
#include <stdlib.h>

int buf[4];
// 특정 메모리에 올라온 함수를 실행하는 방법
void sniper() {
	system("dir");
}

void subroutine(int param) {
	// buffer overflow 공격 지점
	scanf("%s", buf);
}

int main() {
	printf("SNIPER ADDRESS=[Ox%p]\n", sniper);
	subroutine(4);

	return 0;
}

Windows 에서 수행하기위해 Visual Studio 의 디버그-창-디스어셈블리 를 체크하고, subroutine 함수 수행 전 break point 를 지정하여 레지스터창을 이용하면 아래와 같이 어셈블리 코드를 확인 할 수 있습니다.

여기서 중요한 것은 레지스터 창의 ESP(Stack Pointer)의 주소를 디버그-창-메모리 를 이용하여 step 별로 함수에 진입하는 상태를 보면 먼저 파라미터 4를 stack 넣고, 그 다음 함수가 끝나고 돌아올 주소 즉, return address 를 stack 에 넣는 다는 것을 알 수 있습니다.

Buffo overflow 공격은 바로 stack 에 있는 return address를 변경하여 원하는 함수를 실행하여 공격하는게 목표 입니다. 간단히 return address를 원하는 함수 (sniper 함수 주소)로 변경하면 어떤 일이 생기는지 확인 해 보도록 하겠습니다.

Stack 내 Return Address 변경

함수가 정상적으로 종료되지는 않았지만, system("dir") 이란 sniper 함수가 수행되었음을 알 수 있습니다.

최종 dir cmd 가 실행되는 결과

이제 남은 일은 buffer overflow 를 통해 return address 를 특정함수 (sniper ) 주소로 바꾸는 일만 남게 되었습니다.

Digital watermarking (네이버웹툰 캡처 추적) #1

기루광 — Sat, 11 Sep 2021 01:33:39 +0900

월요일 부터 금요일 까지 잠자기 전에 나를 인도해주는 네이버 웹툰을 보다가 문뜩

경고문을 보고는 어..이게 캡처가 된다고 ? 하면서 스마트폰 캡처를 했는데 정말 가능하긴 하네요,

우리 열심히 밤낮없이 일하시는 작가님들 저작권을 어떻게 보호한다는 거지 라는 막연한생각에 한번 간단히 찾아봤습니다.

간단히 찾아 본 Frequency Method 방식 으로 3개가 있네요.

Attack 방법에 대해서 일반적으로 알려진 방법을 사용해보도하겠습니다.

아래 알고리즘들에 대해서 문뜩 필살기처럼 회피할 아이디어가 번뜩이지만, 조용히 테스트만 해보도록 하겠습니다.

이제 첫 번째 이야기를 진행하겠습니다.

DWT-DCT 알고리즘을 통한 watermarking 이미지 embedding - extraction 입니다.

[ Frequency Method ]

- DWT-DCT (첫번째 시리즈)

- DWT-DCT-SVD

- DWT-DCT-SIFT

[ Deep Learning GAN Method]

rivaGan: encoder/decoder model with Attention mechanism + embed watermark bits into vector.

[ 검색 ] 역시 구글링 첫 번째 논문에 DWT-DCT image watermarking 이 나오네요

[ 결론 ] 여러분 함부로 캡처하지 마세요.

(Crop 에 취약하지만, 여러분 2007년 나온겁니다.!! 해결책이 있겠죠)

Combined DWT-DCT Digital Image Watermarking (2007)

Abstract: The proliferation of digitized media due to the rapid growth of networked multimedia systems, has created an urgent need for copyright enforcement technologies that can protect copyright ownership of multimedia objects. Digital image watermarking is one such technology that has been developed to protect digital images from illegal manipulations. In particular, digital image watermarking algorithms which are based on the discrete wavelet transform have been widely recognized to be more prevalent than others. This is due to the wavelets' excellent spatial localization, frequency spread, and multi-resolution characteristics, which are similar to the theoretical models of the human visual system. In this paper, we describe an imperceptible and a robust combined DWT-DCT digital image watermarking algorithm. The algorithm watermarks a given digital image using a combination of the Discrete Wavelet Transform (DWT) and the Discrete Cosine Transform (DCT). Performance evaluation results show that combining the two transforms improved the performance of the watermarking algorithms that are based solely on the DWT transform.

참고로 2007년에 나온 논문인데 인용수가 많은 걸 보고 이거구나 하는 생각에 한번 개략적인 컨셉만 보고 따라해봤습니다.

(** 지금이 2021년,, 14년전 에 나온 논문입니다.)

정확히 전부를 이해하기 위해서는 DCT, DWT 라는 transform 에 대해서 이해를 해야 되는데 추후 업데이트를 해서 자세히 써보도록 하겠습니다.

discrete cosine transform (DCT)
discrete wavelet transform (DWT)

준비1. watermark 이미지

(실제로 사용 프로그램에서는 watermark 이미지를 직접 쓰는일이 없고 암호화/복호화를 통해서 여러분이 추출을 시도해보려고 해도 힘들도록 만들어져 있습니다.)

Watermark Image

준비2. 샘플 이미지

Sample Image

Embedding 과정

손쉽게 말하면 DWT 를 통해 얻어진 이미지에 watermark 이미지를 잘 녹여내고 이를 다시 Inverse DWT를 통하면 원본 이미지와 비슷하면서도 watermark 를 뽑아 낼 수 있는 그림이 완성이 됩니다.

Extraction 과정

Embedding 이미지가 오염되거나 변경, 변화가 생겨도 이를 잘 변환하면 원래의 watermark 이미지를 뽑아 낼 수 있습니다.

결론적으로 DWT-DCT 알고리즘 경우 crop / affine transform 에 취약하네요. 그외 공격에는 그럭저럭 괜찮습니다.

(추출된 watermark 이미지 경우 아래처럼 노이즈가 섞여 있어서 이를 다시 denoising 하기 위한 딥러닝 모델을 통해 digital 로 바꾸는 무언가를 할 필요가 있을 것 같네요. - 기회가 되면 이것도 다루겠습니다.)

Attack	Image	Extraction(watermark)
Embedding (Initial)
Gaussian Blur
Histogram Equalization
Rotation (Left 90)
Rotation (Right 90)
Random Noise (± 10)
Resize

Python code

아래 2개의 함수는 상황에 따라 조정을 해야되서 기존에서 수정을 진행하도록 하겠습니다.

_ebmed_logic
_extract_logic

# https://github.com/diptamath/DWT-DCT-Digital-Image-Watermarking
# https://thescipub.com/pdf/jcssp.2007.740.746.pdf

import os
import cv2

import pywt
import numpy as np
from scipy.fftpack import dct, idct

import matplotlib.pyplot as plt


class WaterMark(object):
    """
    
    """
    def __init__(self, img_shape=2048, mark_shape=128, level=1):
        self.img_shape = img_shape
        self.mark_shape = mark_shape
        self.level = level
        self.kernel = 8
        self.model = 'haar'
        
    def __repr__(self):
        return f'version 0.0.1'
    
    def _load(self, img_path: str, size: int):
        img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
        img = img.astype(np.float32)/255.0
        
        # size x size
        img = cv2.resize(img, (size, size), interpolation=cv2.INTER_CUBIC)
        return img
    
    def _dct_transform(self, img, inverse=False):
        
        h, w = img.shape[:2]
        buffer = np.zeros_like(img)
        trans_func = idct if inverse else dct
        
        for r in range(0, h, self.kernel):
            for c in range(0, w, self.kernel):
                subpixels = img[r:r+self.kernel, c:c+self.kernel]
                buffer[r:r+self.kernel, c:c+self.kernel] = trans_func(
                    trans_func(subpixels.T, norm="ortho").T, norm="ortho")
        return buffer
  
        
    
    def _embed_logic(self, mark, img):
        """
        // TODO: Implementation your logic
        """        
        return img        
        
    
    def embedding(self, img_path: str, mark_path: str):
        img = self._load(img_path, self.img_shape)
        mark =  self._load(mark_path, self.mark_shape)
        
        # [cAn, (cHn, cVn, cDn)
        coeffs = pywt.wavedec2(img, self.model, level=self.level)
        
        dct_cAn = self._dct_transform(coeffs[0])
        dct_cAn = self._embed_logic(mark, dct_cAn)
        coeffs[0] = self._dct_transform(dct_cAn, inverse=True)
                
        embed_img = pywt.waverec2(coeffs, self.model)
        embed_img = cv2.normalize(embed_img, None, 0, 255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8UC1)
        return embed_img
    
    def extract(self, img_path: str):
        img = self._load(img_path, self.img_shape)
        
        # [cAn, (cHn, cVn, cDn)
        coeffs = pywt.wavedec2(img, self.model, level=self.level)        
        dct_cAn = self._dct_transform(coeffs[0])
        mark_img = self._extract_logic(dct_cAn)
        mark_img = cv2.normalize(mark_img, None, 0, 255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8UC1)
        return mark_img
    
        
    def _extract_logic(self, img):
        """
        // TODO: Implementation your logic
        """
        return mark_img
    
if __name__ == '__main__':
    wm = WaterMark()
    img = wm.embedding('sample_2048.jpg', 'watermark.jpg')
    cv2.imwrite('sample_embed.jpg', img)

    mark = wm.extract('sample_embed.jpg')
    cv2.imwrite('extract_mark.jpg', mark)

Distortion Image [ Next ,, 못잡을 것 같지 ? ]

과연 모든 화질을 포기하고 캡쳐를 했을 때 피할 수 있을까요 ? Hint 이미지에 특징점은 쉽게 바뀌지 않아요

참고

https://github.com/diptamath/DWT-DCT-Digital-Image-Watermarking

GitHub - diptamath/DWT-DCT-Digital-Image-Watermarking: A digital image watermarking algorithm based on combining two transforms;

A digital image watermarking algorithm based on combining two transforms; DWT and DCT. - GitHub - diptamath/DWT-DCT-Digital-Image-Watermarking: A digital image watermarking algorithm based on combi...

github.com

Minimum Volume Enclosing Ellipsoid

기루광 — Fri, 23 Oct 2020 22:57:31 +0900

1 http://stackoverflow.com/questions/1768197/bounding-ellipse/1768440#1768440 (stack)

2 http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.116.7691 (document)

3 https://gist.github.com/Gabriel-p/4ddd31422a88e7cdf953 (python mvee code)

$ {(x_i -c)}^TE{(x_i -c)} \leq 1 \hspace{10mm} i=1,...,m $

$Vol(\varepsilon) = {v_0 \over \sqrt{det(E)}} = v_0 det(E^{-1})^{1 \over 2}$

document 를 참조하면 center form 을 이용하여 convex function 으로 변환 후 이를 이용하여

Largrange dual problem 을 가정하여 최적화를 진행하는 방식입니다. 세부 수식은 2 document 를 참조하셔야 됩니다.



import numpy as np
import numpy.linalg as la
import matplotlib.pyplot as plt
from matplotlib.patches import Ellipse

import cv2

def mvee(points, tol = 0.01):
    """
    Finds the ellipse equation in "center form"
    (x-c).T * A * (x-c) = 1
    """
    N, d = points.shape
    Q = np.column_stack((points, np.ones(N))).T
    err = tol+1.0
    u = np.ones(N)/N
    while err > tol:
        # assert u.sum() == 1 # invariant
        X = np.dot(np.dot(Q, np.diag(u)), Q.T)
        M = np.diag(np.dot(np.dot(Q.T, la.inv(X)), Q))
        jdx = np.argmax(M)
        step_size = (M[jdx]-d-1.0)/((d+1)*(M[jdx]-1.0))
        new_u = (1-step_size)*u
        new_u[jdx] += step_size
        err = la.norm(new_u-u)
        u = new_u
    c = np.dot(u,points)        
    A = la.inv(np.dot(np.dot(points.T, np.diag(u)), points)
               - np.multiply.outer(c,c))/d
    return A, c

img = cv2.imread('/home/roadcom/Downloads/partial_ellipse.jpeg', cv2.IMREAD_GRAYSCALE)

ret, th = cv2.threshold(img,0,255,cv2.THRESH_BINARY + cv2.THRESH_OTSU)

conts, _ = cv2.findContours(th,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)

# max bloc filter
max_blob_id = np.argmax([cv2.contourArea(p) for p in conts])

A, centroid = mvee(np.squeeze(conts[max_blob_id]))
U, D, V = la.svd(A)

# x, y radii.
rx, ry = 1./np.sqrt(D)
major, minor = max(rx,ry), min(rx,ry)
    
cxy = tuple(np.int0(centroid))
aixs = tuple(np.int0([major, minor]))

arcsin = -1. * np.rad2deg(np.arcsin(V[0][0]))
arccos = np.rad2deg(np.arccos(V[0][1]))

# Orientation angle (with respect to the x axis counterclockwise).
alpha = arccos if arcsin > 0. else -1. * arccos

rst_img = cv2.ellipse(img.copy(), cxy, aixs, alpha, 0, 360,(255,255,255),3)
B, G, R = cv2.split(rst_img) 
matplot_img = cv2.merge([R,G,B])

fig, axs = plt.subplots(1,2, figsize=(16,8))
axs[0].imshow(img, interpolation='quadric')
axs[0].set_title('Origin[B,G,R]')
axs[0].axis('off')

axs[1].imshow(matplot_img, interpolation='quadric')
axs[1].set_title('MVEE')
axs[1].axis('off')

[keras] GAN 이해 및 구현

기루광 — Sun, 19 Jan 2020 19:22:21 +0900

Generative Adversarial Network

■ minimax problem

$\underset{G}{min}\, \underset{D}{max} V(D, G) = \mathbb{E}_{x \sim P_{\text{data}}(x)} \big[ \log D(x) \big] + \mathbb{E}_{z \sim P_{z}(z)} \big[ \log (1-D(G(z)) \big]$

■ Discriminator

$maximize\quad J^{(D)}= \mathbb{E}_{x \sim P_{\text{data}}(x)} \big[ \log D(x) \big] + \mathbb{E}_{z \sim P_{z}(z)} \big[ \log (1-D(G(z)) \big]$

$\frac{1}{N}\sum_{i=1}^{N}{ y^{i}\,log(\hat{y_{i}}) + (1-y^{i})\,log(1- \hat{y_{i}})}
= -H(p, D)$

$minimize\quad H(p,D) = - \frac{1}{N}\sum_{i=1}^{N}{ y^{i}\,log(\hat{y_{i}}) + (1-y^{i})\,log(1- \hat{y_{i}})}$

■ Generator

$minimize\quad J^{(G)} = \mathbb{E}_{z \sim P_{z}(z)} \big[ \log (1-D(G(z)) \big]$

[ heuristic method ]

학습 초반, discriminator 의 학습이 훨씬 빨리 되기 때문에, D(G(z)) 의 값은 대부분 0에 가까워지게 됩니다.

즉, gradient vanishing 이 발생하게 됩니다.

$\nabla_{\theta_{g}} \frac{1}{m} \sum_{i=1}^{m}\log(1-D(G(z^{i})))\nabla_{\theta_{g}} \frac{1}{m} \sum_{i=1}^{m}\log(1-D(G(z^{i})))\approx 0$

이를 해결하고자 다음의 방법이 많이 사용됩니다.

$maximize\quad J^{(G)} = \mathbb{E}_{z \sim P_{z}(z)} \Big[\log D(G(z))\Big]$

참조

https://medium.com/@jonathan_hui/gan-why-it-is-so-hard-to-train-generative-advisory-networks-819a86b3750b

GAN — Why it is so hard to train Generative Adversarial Networks!

It is easier to recognize a Monet’s painting than drawing one. Generative models (creating data) are considered much harder comparing with…

medium.com

[keras] ResNet (residual block)

기루광 — Sun, 12 Jan 2020 13:22:46 +0900

■ Degradation 문제

Deep Residual Learning for Image Recognition 논문을 보면 시작은

56-layer를 사용하면 이론적으로 더 error 가 낮아야 하지만, 20-layer 보다 더 높은 값을 나타내고 있습니다.

이는 다시말하면 layer가 깊어질수록 overfitting 의 문제가 아닌, training error 가 증가한다는 말로

네트워크가 학습이 잘 진행이 되지 않는다는 것을 의미합니다.

■ Shortcut connection (skip connection)

Degradation 문제를 해결하기 위해 논문에서 제안한 방법이 shutcut connection 이란 방법으로

Gradient 를 유지할 수 있도록 shorcut을 만든 다는 것이 핵심입니다.

$y_{l} = h(x_l) + F(x_l, W_l) \qquad h:identity mapping,\quad x: input $

$x_{l+1} = f(y_{l}) \qquad x_{l+1}:output, \quad f: activation function$

일반화

$x_{l+2} = x_{l+1} + F(x_{l+1}, W_{l+1}) = x_{l} + F(x_{l}, W_{l}) + F(x_{l+1},W_{l+1})= x_l+ \dots +$

$x_{L} = x_{l} + \sum_{i=1}^{L-1}F(x_i,W_i)$

역전파(Back propagation)

$\frac{\partial \varepsilon }{\partial x_l} = \frac{\partial \varepsilon }{\partial x_L} \frac{\partial x_L }{\partial x_l} = \frac{\partial \varepsilon }{\partial x_L} (1 + \frac{\partial}{\partial x_l}\sum_{i=1}^{L-1}F(x_i,W_i))$

$ (1 + \frac{\partial}{\partial x_l}\sum_{i=1}^{L-1}F(x_i,W_i)) $ 왼쪽 항과 오른쪽 항으로 구분되게 됩니다.

Mini batch 로 진행된다고 가정하면 실제 오른쪽 항이 전부 -1을 만족하는 경우가 거의 없기에 Gradient 값이 유지됩니다.

■ Identity Block / Convolutional Block

Identity Block

Shortcut 의 channel 과 main path 의 channel 이 일치할 경우 단순 add 연산만 진행하는 블록을 identity block 이라고 합니다.

Identity Block

Convolution Block

Shortcut 의 channel 과 main path 의 channel 이 다를 경우 shortcut path 를 적절히 변환해주는 작업

즉, projection 을 통해 channel 을 맞춰주는 작업이(projection shortcut) 추가되기에 이를 convolution block 이라고 합니다.

Convoltional Block

Resnet-50 Structure

Total Structure of ResNet-50

* 그림 출처: https://github.com/YBIGTA/DeepNLP-Study/wiki/Day-02-Paper-Review:-ResNet

* 참고 : https://arxiv.org/pdf/1512.03385.pdf

■ Residual Block (Keras)


from keras import layers

def residual_block(x, filters_in, filters_out, k_size):
    shortcut = x
    x = layers.Conv2D(filters_in, kernel_size=(1, 1), strides=(1, 1), padding="same")(x)
    x = layers.BatchNormalization()(x)
    x = layers.LeakyReLU()(x)
    
    x = layers.Conv2D(filters_in, kernel_size=(k_size, k_size), strides=(1, 1), padding="same")(x)
    x = layers.BatchNormalization()(x)
    x = layers.LeakyReLU()(x)    
    
    x = layers.Conv2D(filters_out, kernel_size=(1, 1), strides=(1, 1), padding="same")(x)
    x = layers.BatchNormalization()(x)
    
    shortcut_channel = x.shape.as_list()[-1]
    
    if shortcut_channel != filters_out:
        shortcut = layers.Conv2D(filters_out, kernel_size=(1, 1), strides=(1, 1), padding="same")(shortcut)
        
    x = layers.Add()([x, shortcut])
    return layers.LeakyReLU()(x)

[python] asyncio, aiohttp web crawling

기루광 — Mon, 6 Jan 2020 23:42:31 +0900

asyncio 와 asiohttp 에 대한 자세한 내용은 구글을 검색을 통해 얻을 수 있습니다.

single thread 를 활용한 비동기 프로그래밍 이라고 생각하시면 될 것 같습니다.

I/O Bound 와 CPU Bound 라는 개념 또한 나오는데 Synchronous(동기) 방식을 사용하면 I/O Bound 성능에 따라서

프로그램의 속도에 아주 큰 영향을 미치게 됩니다.

(asyncio 에 대해서 추후 정리하도록 하겠습니다.)

동기 방식을 이용하여 간단히 네이버 금융을 통해서 삼성전자의 주식을 50페이지 정도 조회하게 되면

1.797 s 의 시간이 소요 됩니다.

import requests
import time


url = 'https://finance.naver.com/item/sise_day.nhn?code={code}&page={page}'


def sync_fetch():
    res = [requests.get(url.format(code='005930', page=i))
           for i in range(1, 50)]
    return res


if __name__ == '__main__':

    start = time.time()
    sync_fetch()
    end = time.time()
    print(f"elapsed time = {end - start}s")

elapsed time = 1.797

비동기 프로그래밍을 통해 똑같은 방식으로 대략 14배 이상이 빨리지는 성능을 얻을 수 있습니다.

import aiohttp
import asyncio
import time


async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()


async def main():
    async with aiohttp.ClientSession() as session:

        url = 'https://finance.naver.com/item/sise_day.nhn?code={code}&page={page}'
        futures = [asyncio.ensure_future(fetch(session, url.format(code='005930', page=i)))
                   for i in range(1, 50)]
        res = await asyncio.gather(*futures)
        return res

if __name__ == '__main__':

    loop = asyncio.get_event_loop()
    start = time.time()
    result = loop.run_until_complete(main())
    end = time.time()
    print(f"elapsed time = {end - start}s")
    loop.close()

elapsed time = 0.124

[수정 중] Feature selection

기루광 — Sat, 3 Aug 2019 23:39:35 +0900

ML 과 DL 에서 feature selection 을 이용하는 알고리즘과 해당 내용에 대해서 써볼 예정입니다.

Autoencoder

Random forest

PCA

Machine Learning

- Filter Method

(통계 테스트)

- Wrapper Method

(Forward Selection, Backward Elimination, Recursive Feature Elimination)

- Embedded Method

(LASSO, RIDGE)

[참고] https://sherry-data.tistory.com/12

Backpropagation 예제 및 구현

기루광 — Thu, 25 Jul 2019 23:00:37 +0900

Reference 오카타니 타카유키, 『딥러닝 제대로 시작하기』, jpub(2016), p58~p63

위 책을 읽고 코드로 구현하기에 적합하도록 수식을 변경하여 정리했습니다.

keras, tensorflow 등의 라이브러리 없이 numpy 행렬 연산을 통해 직접 feed forward, back propagation 을 구현하여 학습을 할 수 있도록 코드를 구현했습니다.

일반 적인 Perceptron 구조

Perceptron

다수의 입력을 받아서 모두 더한 뒤 특정한 함수를 통과시켜 얻은 결과는 아래와 같이 정리할 수 있습니다.

$ u = \sum_{i=1}^{3}{w_i \cdot a_i} + b $

$ z = f(u) $ f : activation function

Multiple Layer Perceptron

■ 다층 layer를 가지는 퍼셉트론을 도식화 하면 아래와 같은 그림으로 표현 가능합니다.

Multiple Layer Perceptron

우선 진행에 앞서 혼동이 되지 않도록 수식에 대해 정의를 하고 넘어가겠습니다.

$ u_{j}^{(l)} $ → l - layer 의 j-th 노드 (활성함수를 통과 전)

$ z_{j}^{(l)} $ → l - layer 의 j-th 노드 (활성함수를 통과 후)

$ w_{ij}^{(l)} $ → (l-1) layer 의 i-th 노드 에서 (l) layer 의 j-th 노드로 가는 가중치

$u_{i}^{(l-1)} = z_{i}^{(l-1)}$ → 입력층 노드는 활성함수가 없음

$u_{k}^{(l+1)} = z_{k}^{(l+1)}$ → 출력층 노드는 활성함수가 없음

Feed forward

앞 방향으로 나가는 결과 값을 계산하는 것은 아래처럼 쉽게 계산이 됩니다.

$ u_k = \sum_{j=1}^{3}{ w_{jk}^{(l+1)}z_{j}^{l} + b_{k}^{(l+1)} } = \sum_{j=0}^{3}{w_{jk}^{(l+1)}z_{j}^{(l)} } = \sum_{j=0}^{3}{w_{jk}^{(l+1)}f(u_{j}^{(l)}) } \leftarrow w_{0k}^{l+1}=b_k^{l+1} , z_0^{l}=1 $

Back-propagation

문제는 weight 들을 학습하기 위해 gradient descent 방식으로 업데이트 하는 과정이 간단하지 않아

이를 정리 하고자 아래와 같이 수식을 다시 정리해 보도록 하겠습니다.

여기서의 E (loss function)은 간단히 mse 로 정의하고 진행하겠습니다.

$ E = \sum_{k=1}^{3} {(y_k - d_k)}^2 $

${\large {\partial E \over \partial w_{jk}^{(l+1)}} = {\partial E \over \partial u_{j}^{(l+1)}}\cdot {\partial u_{j}^{(l+1)} \over \partial w_{jk}^{(l+1)}}{\partial E \over \partial w_{jk}^{(l+1)}} = {\partial E \over \partial u_{j}^{(l+1)}}\cdot {\partial u_{j}^{(l+1)} \over \partial w_{jk}^{(l+1)}} = (y_k -d_k)\cdot{\partial \sum_j{w_{jk}^{(l+1)} \cdot {z_j^{(l)}} } \over \partial w_{jk}^{(l+1)}}
= (y_k -d_k)\cdot {z_j^{(l)}}
}$

$ \begin{align*}{\partial E \over \partial w_{ij}^{(l)}} & = {\partial E \over \partial u_{j}^{(l)}} {\partial u_{j}^{(l)} \over \partial w_{ij}^{(l)}} = {\partial E \over \partial u_{j}^{(l)}} \cdot z_i^{l-1} = {\sum_{k=0}^{3}{ {\partial E \over \partial u_{k}^{(l+1)}} {\partial u_{k}^{(l+1)} \over \partial u_{j}^{(l)}} } } \cdot z_i^{l-1} \\ & =
\left ( f'(u_j^{l}) \sum_{k}{w_{jk}^{(l+1)}(u_k^{(l+1)} - d_k)}\right )z_i^{(l-1)} \end{align*} $

$\begin{align*} {\partial E \over \partial w_{ij}^{(l)}} = {\partial E \over \partial u_{j}^{(l)}}{\ \partial u_{j}^{(l)} \over \partial w_{ij}^{(l)}} =\delta_{j}^{(l)}{\ \partial u_{j}^{(l)} \over \partial w_{ij}^{(l)}} \quad \leftarrow \quad {\partial E \over \partial u_{j}^{(l)}} = \delta_{j}^{(l)} \end{align*}$

$ \begin{align*} {\partial E \over \partial u_{j}^{(l)}} & = \sum_{k}{{\partial E \over \partial u_{k}^{(l+1)}}
{\partial u_{k}^{(l+1)} \over \partial u_{j}^{(l)}} } = \sum_{k}{{\partial E \over \partial u_{k}^{(l+1)}} \cdot
\left ( w_{jk}^{(l+1)} f'(u_j^{(l)})\right )} \\ & = \sum_{k}{\delta_k^{(l+1)}\left ( w_{jk}^{(l+1)} f'(u_j^{(l)})\right )} \quad l=2, 3,\dots ,L-1 \end{align*} $

여기서 중요한 것은 델타 함수가 출력층에서 멀어져도 출력층을 이용하여

전파되는 양을 수식으로 정의할 수 있게 되었습니다.

$\delta_{j}^{(l)}=\sum_{k}{\delta_k^{(l+1)}\left ( w_{jk}^{(l+1)} f'(u_j^{(l)})\right )}$

Back-propagation matrix form


import numpy as np
import matplotlib.pyplot as plt

class MLP(object):
    """
    Using Keras and tensorflow, it is easy to learn. 
    However, it is implemented by using only numpy for feed forward and back propagation.

    Args:
        layers : [xs_dim, node, ... , node, out_dim]    

    mr.xeros@gmail.com [roadk]
    """
    
    @staticmethod
    def sigmoid(x):
        return 1/(1+np.power(np.e, -x))

    @staticmethod
    def identity(x):
        return x

    @staticmethod
    def inv_sig(x):
        tmp = MLP.sigmoid(x)
        return tmp*(1-tmp)

    def __init__(self, **kwargs):


        self.layers = kwargs['layers']
        self.activate = [MLP.identity]
        self.weights = [1]
        self.bias = [0]
        self.lr = 0.002

        for i in range(1, len(self.layers)):
            self.weights.append(np.random.normal(0, 0.5, (self.layers[i-1],self.layers[i])))
            self.bias.append(np.random.normal(0, 0.5, self.layers[i]))

            if i != len(self.layers) -1:
                self.activate.append(MLP.sigmoid)
            else:
                self.activate.append(MLP.identity)

    def feed_forward(self, xs):

        self.U = [xs]
        self.Z = [xs]

        for i in range(1, len(self.layers)):
            u = self.Z[i-1].dot(self.weights[i]) + self.bias[i]
            z = self.activate[i](u)
            self.U.append(u)
            self.Z.append(z)

        return self.Z[-1]


    def back_propagate(self, xs, ys):

        pred_ys = self.feed_forward(xs)
        self.D = []

        for i in reversed(range(1,len(self.layers))):
            if i == len(self.layers) - 1:
                d = pred_ys - ys
            else:
                d = self.inv_sig(self.U[i])*(self.D[-1].dot(self.weights[i+1].T))

            dW = self.Z[i-1].T.dot(d)
            db = np.sum(d, axis=0)

            self.weights[i] -= self.lr*dW
            self.bias[i] -= self.lr*db

            self.D.append(d)
        return

    def evaluate(self, xs, ys):
        pred_ys = self.feed_forward(xs)
        d = pred_ys - ys
        return np.mean(np.sqrt(d**2))
    

if __name__ == '__main__':
    
    model = MLP(layers=[1,5,5,5,1])
    
    train_x = np.linspace(-5,5,100)
    train_y = np.sin(train_x)

    xs = train_x.reshape(-1,1)
    ys = train_y.reshape(-1,1)

    pred_ys = model.feed_forward(xs)

    for i in range(50000):
        model.back_propagate(xs, ys)

        if (i+1) % 5000 == 0:
            error = model.evaluate(xs, ys)
            print('ITER={:05d}, RMSE={:.4f}'.format(i+1, error))
            
    pred_ys = model.feed_forward(xs)
    
    plt.plot(xs.ravel(), pred_ys.ravel(), label='prediction')
    plt.plot(xs.ravel(), train_y.ravel(), label='original')
    plt.legend()

Naive Gradient descent 와 sigmoid 를 사용하였고, numpy 사용하여 weights 들을 학습한 결과를 보면 어느정도 학습이 된 것을 확인 할 수 있습니다.

Numpy 만 사용하여 학습한 결과

[keras] vae spectrum generator

기루광 — Sat, 27 Apr 2019 12:37:31 +0900

* Variational Autoencoder

생성 모델 중 VAE 정리 진행 중 (영상 대신 1d 시그널 생성 모델)

# coding: utf-8

# In[1]:


import os
import keras
import numpy as np
import matplotlib.pyplot as plt

import tensorflow as tf


# In[2]:


def sinosoidal(v):
    
    fix_wave = np.arange(100)
    
    return (fix_wave**0.2)*np.sin(0.3*fix_wave + v) + v


# In[3]:


spectrum_y = np.random.normal(size=(1000,1),scale= 0.5)
spectrum_x = np.vstack([sinosoidal(i[0]) for i in spectrum_y])

xmean,xstd = spectrum_x.mean(), spectrum_x.std()
ymean,ystd = spectrum_y.mean(), spectrum_y.std()

stdz_x = (spectrum_x - xmean)/xstd
stdz_y = (spectrum_y - ymean)/ystd

total_size = len(stdz_x)
rand_idx = np.random.permutation(total_size)

x_train = stdz_x[rand_idx][:int(0.7*total_size)]
x_valid = stdz_x[rand_idx][int(0.7*total_size):int(0.8*total_size)]
x_test =  stdz_x[rand_idx][int(0.8*total_size):]


# In[4]:


for i in stdz_x:
    plt.plot(i)


# In[ ]:


from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from keras.layers import Lambda, Input, Dense
from keras.models import Model
from keras.datasets import mnist
from keras.losses import mse, binary_crossentropy
from keras.utils import plot_model
from keras import backend as K

import numpy as np
import matplotlib.pyplot as plt
import argparse
import os


# reparameterization trick
# instead of sampling from Q(z|X), sample epsilon = N(0,I)
# z = z_mean + sqrt(var) * epsilon
def sampling(args):
    """Reparameterization trick by sampling from an isotropic unit Gaussian.
    # Arguments
        args (tensor): mean and log of variance of Q(z|X)
    # Returns
        z (tensor): sampled latent vector
    """

    z_mean, z_log_var = args
    batch = K.shape(z_mean)[0]
    dim = K.int_shape(z_mean)[1]
    # by default, random_normal has mean = 0 and std = 1.0
    epsilon = K.random_normal(shape=(batch, dim))
    return z_mean + K.exp(0.5 * z_log_var) * epsilon


def plot_results(models,
                 data,
                 batch_size=128,
                 model_name="vae_mnist"):
    """Plots labels and MNIST digits as a function of the 2D latent vector
    # Arguments
        models (tuple): encoder and decoder models
        data (tuple): test data and label
        batch_size (int): prediction batch size
        model_name (string): which model is using this function
    """

    encoder, decoder = models
    x_test, y_test = data
    os.makedirs(model_name, exist_ok=True)

    filename = os.path.join(model_name, "vae_mean.png")
    # display a 2D plot of the digit classes in the latent space
    z_mean, _, _ = encoder.predict(x_test,
                                   batch_size=batch_size)


    for i, yi in enumerate(grid_y):
        for j, xi in enumerate(grid_x):
            z_sample = np.array([[xi, yi]])
            x_decoded = decoder.predict(z_sample)
            digit = x_decoded[0].reshape(digit_size, digit_size)
            figure[i * digit_size: (i + 1) * digit_size,
                   j * digit_size: (j + 1) * digit_size] = digit



# MNIST dataset


print(spectrum_x.shape, spectrum_y.shape)


original_dim = spectrum_x.shape[1]


# network parameters
input_shape = (original_dim, )
intermediate_dim = 3
batch_size = 64
latent_dim = 2
epochs = 5000

# VAE model = encoder + decoder
# build encoder model
inputs = Input(shape=input_shape, name='encoder_input')
x = Dense(intermediate_dim, activation='relu')(inputs)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)

# use reparameterization trick to push the sampling out as input
# note that "output_shape" isn't necessary with the TensorFlow backend
z = Lambda(sampling, output_shape=(latent_dim,), name='z')([z_mean, z_log_var])

# instantiate encoder model
encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder')
encoder.summary()
plot_model(encoder, to_file='vae_mlp_encoder.png', show_shapes=True)

# build decoder model
latent_inputs = Input(shape=(latent_dim,), name='z_sampling')
x = Dense(intermediate_dim, activation='relu')(latent_inputs)
# outputs = Dense(original_dim, activation='sigmoid')(x)
outputs = Dense(original_dim)(x)

# instantiate decoder model
decoder = Model(latent_inputs, outputs, name='decoder')
decoder.summary()
plot_model(decoder, to_file='vae_mlp_decoder.png', show_shapes=True)

# instantiate VAE model
outputs = decoder(encoder(inputs)[2])
vae = Model(inputs, outputs, name='vae_mlp')


models = (encoder, decoder)
reconstruction_loss = mse(inputs, outputs)

reconstruction_loss *= original_dim
kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
vae_loss = K.mean(reconstruction_loss + kl_loss)
vae.add_loss(vae_loss)
vae.compile(optimizer='adam')
vae.summary()
plot_model(vae,to_file='vae_mlp.png',show_shapes=True)

vae.fit(x_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, None), verbose=1)
vae.save_weights('vae_mlp_mnist.h5')
# plot_results(models, data, batch_size=batch_size, model_name="vae_mlp")


# In[26]:


x_decoded = decoder.predict(np.random.random((1000,2))*3)


# In[27]:


for i in x_decoded:
    plt.plot(i)

Origin spectrum

VAE generator spectrum

Retriever 프로젝트

기루광 — Sat, 2 Dec 2017 23:01:14 +0900

시스템 인터페이스 관련 일들을 진행하다 보면,

생산자(Producer)로 부터 오는 정보를 이용하여 소비자(Consumer) 로 바로 넘겨주지 못하고,

대부분 오는 정보를 이용하여 무언가를 덧붙이고 수정하여 넘겨주게 됩니다.

그래서 agent 를 만들어서 필요한 정보들을 파싱하고 더 필요한 파일들을 모아서

소비자(Consumer)가 쓰기 편한 형태로 제공합니다.

이런 작업을 하는 agent 를 retriever 라고 사냥개 이름에 빚대서

생산자로 부터 넘어온 데이터를 이용하여 원하는 정보들을 잘 물어오는 agent 를 만들어보겠습니다.

언어 : C++

DB : MySQL

Message Queue : RabbitMQ

코드는 아래 Git을 통해서 통해서 업데이트 하겠습니다.

https://github.com/elentail/BGMs/branches

진행사항은 대략적으로 아래 업데이트 하도록 하겠습니다.

1. Message Queue 설치 (RabbitMQ server)

작업을 분배하는 message server 는 아래 설치과정을 보시면 알겠지만, 단 10 분이면 설치 가능합니다.




Last login: Tue Dec  5 20:49:45 2017 from 175.115.214.213

#1.  rabbitmq-server  설치
roadking@gcloud:~$ sudo apt install rabbitmq-server -y
[sudo] password for roadking: 
Reading package lists... Done
Building dependency tree       
Reading state information... Done
The following package was automatically installed and is no longer required:
  linux-headers-4.10.0-37
...

#2.  rabbitmq-server  상태 확인(active)
roadking@gclouds:~$ sudo systemctl status rabbitmq-server
● rabbitmq-server.service - RabbitMQ Messaging Server
   Loaded: loaded (/lib/systemd/system/rabbitmq-server.service; enabled; vendor 
   Active: active (running) since Tue 2017-12-05 20:55:06 UTC; 3min 9s ago
 Main PID: 18165 (rabbitmq-server)
   CGroup: /system.slice/rabbitmq-server.service
           ├─18165 /bin/sh /usr/sbin/rabbitmq-server
           ├─18182 /bin/sh -e /usr/lib/rabbitmq/bin/rabbitmq-server
           ├─18243 /usr/lib/erlang/erts-7.3/bin/epmd -daemon
           ├─18301 /usr/lib/erlang/erts-7.3/bin/beam.smp -W w -A 64 -P 1048576 -
           ├─18418 inet_gethost 4
           └─18419 inet_gethost 4

Dec 05 20:55:04 gclouds systemd[1]: Starting RabbitMQ Messaging Server...
Dec 05 20:55:05 gclouds rabbitmq[18166]: Waiting for rabbit@gclouds ...
Dec 05 20:55:05 gclouds rabbitmq[18166]: pid is 18182 ...
Dec 05 20:55:06 gclouds systemd[1]: Started RabbitMQ Messaging Server.

#3.  관리용 플러그인 설치
roadking@gclouds:~$ sudo rabbitmq-plugins enable rabbitmq_management
The following plugins have been enabled:
  mochiweb
  webmachine
  rabbitmq_web_dispatch
  amqp_client
  rabbitmq_management_agent
  rabbitmq_management

Applying plugin configuration to rabbit@gclouds... started 6 plugins.

#4.  관리용 플러그인 설치로 해당 서비스 재시작
roadking@gclouds:~$ sudo systemctl restart rabbitmq-server

#5.  luffy/onepiece 로 관리용 계정 생성
roadking@gclouds:~$ sudo rabbitmqctl add_user luffy onepiece
Creating user "luffy" ...

#6.  해당 계정을 관리자(administrator) 로 설정
roadking@gclouds:~$ sudo rabbitmqctl set_user_tags luffy administrator
Setting tags for user "luffy" to [administrator] ...
roadking@gclouds:~$

[ RabbitMQ Server - 관리 페이지 접속 http://IP:15672 , luffy/onepiece]

2. DB 설치(MySQL)


#1.  mysql 서버 설치
roadking@gclouds:~$ sudo apt  install mysql-server

#2. mysql 서버 상태 확인
roadking@gclouds:~$ systemctl status mysql
● mysql.service - MySQL Community Server
   Loaded: loaded (/lib/systemd/system/mysql.service; enabled; vendor preset: enabled)
   Active: active (running) since Tue 2017-12-05 21:41:00 UTC; 2min 18s ago
 Main PID: 23166 (mysqld)
   CGroup: /system.slice/mysql.service
           └─23166 /usr/sbin/mysqld

#3. mysql 서버 접속
roadking@gclouds:~$ mysql -u root -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 5
Server version: 5.7.20-0ubuntu0.16.04.1 (Ubuntu)

Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

2. DB 설치(MySQL)

[ Lagrange multiplier ] 두 타원 간의 최소거리

기루광 — Fri, 24 Nov 2017 23:07:02 +0900

* shortest path, Lagrange multiplier, constrained optimization

* 라그랑주 승수법

이 번주 너무 바쁜 핑계로 후배에게 한가지 일을 시켰습니다.

" 영상에서 두 blob 간에 최소거리를 측정하는 모듈을 만들어서 줘 "

후회를 시키지않는 똑똑한 후배는 역시 해당 모듈을 뚝딱 만들어서 보내줬습니다.

그런데 한가지 단점이 보이기 시작했네요, 속도가 너무 느린 것 같아요.

두 blob 의 중심을 이용하여 외각선을 추려서 해당 point to point 비교로 최소 거리를 측정하여

이중 for 문으로 $O(n^2)$ 가 나와 버리는 단점이 생겼네요,,,

이러한 속도 문제점 때문에 numerical method 방식으로 문제를 풀어 볼 수는 없을까요?

제한 조건이 있는 최적화 문제

라그랑주 승수법(Lagrange multiplier)

수식으로 표시할 수 있는 제한조건의 최적화 문제는 라그랑주 승수법(Lagrange multiplier)을 사용하여 최적화 할 수 있습니다.

위키피디아 (https://en.wikipedia.org/wiki/Lagrange_multiplier) 에 나와 있는 내용처럼 제약된 문제를 제약이 없는 문제로 바꿔서 풀 수 있습니다.

우선 아래와 같이 최적화 함수와 제한 조건을 정의 합니다. 제한 조건의 등호에 유의 하셔야 합니다.

최적화 하려는 함수 $f(x,y)$

제한 조건 $g(x,y) = 0$

f, g 1차 편미분에 대해 연속이라 가정하면, 새로운 변수 λ(Lagrange multiplier) 도입하여
Lagrange function 정의 할 수 있습니다. 단순히 2개 함수를 하나의 표현식으로 나타낼 수 있습니다.

$ \mathcal{L}(x,y,\lambda) = f(x,y) -\lambda \cdot g(x,y)$

[ General case ]

$ \mathcal{L}(x_1,\cdots,x_n,\lambda_1,\cdots,\lambda_M) = f(x_1,\cdots,x_n) - \sum_{k=1}^M \lambda_kg_k(x_1,\cdots,x_n) $

위키피디아에서 설명한 것처럼 g=0 의 둘레를 돌다 보면 f 와 평행해 보이는 곳이 나타날 것인데, 이러한 지점들이 minma, maxima 중에 하나가 될 것입니다.

이 의미를 잘 해석해보면 2가지로 해석이 되는데

1. f, g 두 함수가 평행해 지는 곳

2. f 함수 자체가 변하지 않아 g=0 의 둘레 어느 곳이든 똑같아 보이는 현상

$ \nabla_{x,y,z} \mathcal{L}(x,y,\lambda) = 0 \iff \begin{cases} \nabla_{x,y}f(x,y)=\lambda\nabla_{x,y}g(x,y), \\ g(x,y)=0, \end{cases}$

[ General case ]

$ \nabla_{x_1,\cdots,x_n,\lambda_1,\cdots,\lambda_M} \mathcal{L}(x_1,\cdots,x_n,\lambda_1,\cdots,\lambda_M) = 0 \iff \begin{cases} \nabla f(\mathbf{x}) -\sum_{k=1}^M \lambda_k g_k(\mathbf{x}) , \\ g_1(\mathbf{x})=\cdots=g_M(\mathbf{x}) = 0, \end{cases}$

위 수식에서 변수 n + M 식이 n + M 가 존재하기 때문에 충분히 풀 수가 있습니다.

다들 아시겠지만 gradient 의 결과는 vector 나오기 때문에 n x 1 의 column vector 로 n 개의 등식이 존재합니다.

(g1= ... = gM = 0 여기서 M 개, gradient f = lambda g 에서 n 개)

설명을 위해 머나먼 길을 돌아온 것 같네요 ^^

Lagrange multiplier 를 이용한 최적화 문제

문제

두 타원의 최소거리를 구하려고 합니다. 물론 각 점들은 타원 1과 타원 2 안에 있는 후보 중 어느 2개의 점입니다.

최적화 함수

$d^2 = [(x_1 -x_2)^2 + (y_1 - y_2)^2].$

제한 조건

$g(x_1,y_1)=a_1 x_1^2 + b _1y_1^2 + c_1 x _1y_1 + d_1 x_1 + e _1y_1 + f_1 =0.$

$g(x_2,y_2)=a_2 x_2^2 + b _2y_2^2 + c_2 x _2y_2 + d_2 x_2 + e _2y_2 + f_2 =0.$

[ 원본 영상 - 손으로 그려서 조잡합니다...]

[ 두 타원(blob) 간의 최소 거리 ]

코드


#!/usr/bin/env python

from __future__ import division
from __future__ import print_function
from __future__ import absolute_import


import cv2
import numpy as np
import os,re,sys,argparse

import scipy.optimize as sp

def fit_rotated_ellipse(data):

    """
    Least Square Mean 방식으로 타원 피팅
    model -> ax^2 + by^2 + cxy + dx + ey + f = 0 
    """
    xs = data[:,0].reshape(-1,1) 
    ys = data[:,1].reshape(-1,1)

    J = np.mat( np.hstack((xs*ys,ys**2,xs, ys, np.ones_like(xs,dtype=np.float))) )
    Y = np.mat(-1*xs**2)
    P= (J.T * J).I * J.T * Y

    a = 1.0; b= P[0,0]; c= P[1,0]; d = P[2,0]; e= P[3,0]; f=P[4,0];

    return np.array([a,b,c,d,e,f])


def find_shorted_ellipses(contours,img_path):

    """
    opencv 에서 제공하는 fitEllipse 함수와
    실제 어느정도 차이가 나는지 확인을 할 수 있도록
    fitEllipse 함수를 통해서 타원을 그려보겠습니다.
    """

    ellipse1 = cv2.fitEllipse(contours[0])
    ellipse2 = cv2.fitEllipse(contours[1])


    e1 = fit_rotated_ellipse(contours[0].reshape(-1,2))
    e2 = fit_rotated_ellipse(contours[1].reshape(-1,2))


    # subject
    distance2e = lambda x : (x[0]-x[2])**2 + (x[1]-x[3])**2


    # constraint equation 1
    e1const = lambda x : \
            e1[0]*(x[0]**2) + e1[1]*(x[0]*x[1]) + \
            e1[2]*(x[1]**2) + e1[3]*x[0] + e1[4]*x[1] + e1[5]


    # constraint equation 2
    e2const = lambda x : \
            e2[0]*(x[2]**2) + e2[1]*(x[2]*x[3]) + \
            e2[2]*(x[3]**2) + e2[3]*x[2] + e2[4]*x[3] + e2[5]

    rst = sp.fmin_slsqp(distance2e,np.array([450,600,550,200]),eqcons=[e1const,e2const])
    print(rst)

    src = cv2.imread(img_path,cv2.IMREAD_COLOR)
    cv2.ellipse(src,ellipse1,(200,30,30),2)
    cv2.ellipse(src,ellipse2,(200,30,30),2)
    cv2.line(src,(int(rst[0]),int(rst[1])),(int(rst[2]),int(rst[3])),(20,250,20),3)
    cv2.imwrite('shorted.jpg',src)



    return

def find_contours(img_path):
    """
    img_path : 입력 이미지 path
    return : 2 개의 타원의 외각선을 찾아 retrun [외각선1,외각선2]
    """

    src = cv2.imread(img_path,cv2.IMREAD_GRAYSCALE)

    h, w = src.shape[:2]
    mask = np.zeros((h+2, w+2), np.uint8)

    _,thv = cv2.threshold(src,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
    cv2.floodFill(thv,mask,(w-1,h-1),0)

    ret_contours= []

    _,cts,_= cv2.findContours(thv.copy(),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_NONE)
    for con in cts:
        p = len(con)
        a = cv2.contourArea(con)
        if(a > 2000 and (1.0-p**2)/(4.0*np.pi*a) < 0.1):
            ret_contours.append(con)

    return ret_contours


if __name__ == '__main__':

    """
    usage> python  two_ellipse.py --img_path=...
    """
    parser = argparse.ArgumentParser()
    parser.add_argument("--img_path",help="the image path")
    if(len(sys.argv) != 2):
        parser.print_help()
        parser.exit()

    args = parser.parse_args()
    cons = find_contours(args.img_path)
    find_shorted_ellipses(cons,args.img_path)

[ 참고 ]

Fabian, how to calculate minimum distance between two arbitrary ellipses in 2d,

MATHEMATICS,LINK [2012.9.10]

데이터 사이언스 스쿨, 제한조건이 있는 최적화 문제. 2017-06-09, LINK

[ slim ] model-inception

기루광 — Mon, 9 Oct 2017 00:40:08 +0900

** 정리 중

기존에도 TF Slim 을 통해서 4개 그룹 (병아리, 매, 비둘기, 참새) 에 대해서 잠깐 포스팅을 한 적이 있는데,

따라하시기에 내용이 부족하여 진행한 내용에 대해서 세부적으로 코드 및 진행 내용에 대해서 다시 포스팅 올립니다.

code - https://github.com/elentail/tensortuto.git

Web scraping 을 통해 dataset 구성
최신 tf-slim 설치
Dataset 을 tf record format 으로 변환
Train set 을 통해 model 학습
Validation set을 통해 model validation
Test set을 통해 학습된 model 평가

1.Preparing dataset

크롤링 (web scraping) 을 통해 4개의 그룹에 대해서 dataset 을 구성
(제가 사용한 데이터를 제공하고 싶지만, 아쉽게도 이부분은 얼마 걸리지 않으니 모아보셔야 됩니다.)
이미지는 Train 252, Validation 64 개 사용
(birds_photos 폴더 밑에 4개의 폴더를 생성하고 해당 이미지를 저장)
Test 이미지는 평가를 위해 다른 폴더에 저장
(최종 평가시, 파일 이름을 통해 결과 내용을 보여주기 위해 파일 이름을 test_{class_num} 형식으로 저장)

2. Installing latest TF Slim

git clone https://github.com/tensorflow/models/



## 참조 tfrecord 저장 및 로딩
## http://www.machinelearninguru.com/deep_learning/tensortuto/basics/tfrecord/tfrecord.html 

## git clone
roadking@rhinoceros:~/workspace$ git clone https://github.com/tensorflow/models/
Cloning into 'models'...
remote: Counting objects: 7608, done.
remote: Compressing objects: 100% (6/6), done.
remote: Total 7608 (delta 0), reused 2 (delta 0), pack-reused 7602
Receiving objects: 100% (7608/7608), 157.89 MiB | 264.00 KiB/s, done.
Resolving deltas: 100% (4111/4111), done.
Checking connectivity... done.


# slim folder 로 이동
roadking@rhinoceros:~/workspace$ cd models/research/slim/

roadking@rhinoceros:~/workspace/models/research/slim$ ll
total 160
drwxrwxr-x  7 roadking roadking  4096 10월  9 00:03 ./
drwxrwxr-x 37 roadking roadking  4096 10월  9 00:03 ../
-rw-rw-r--  1 roadking roadking  9842 10월  9 00:03 BUILD
drwxrwxr-x  2 roadking roadking  4096 10월  9 00:03 datasets/
drwxrwxr-x  2 roadking roadking  4096 10월  9 00:03 deployment/
-rw-rw-r--  1 roadking roadking  2306 10월  9 00:03 download_and_convert_data.py
-rw-rw-r--  1 roadking roadking  6666 10월  9 00:03 eval_image_classifier.py
-rw-rw-r--  1 roadking roadking  4658 10월  9 00:03 export_inference_graph.py
-rw-rw-r--  1 roadking roadking  1397 10월  9 00:03 export_inference_graph_test.py
-rw-rw-r--  1 roadking roadking     0 10월  9 00:03 __init__.py
drwxrwxr-x  2 roadking roadking  4096 10월  9 00:03 nets/
drwxrwxr-x  2 roadking roadking  4096 10월  9 00:03 preprocessing/
-rw-rw-r--  1 roadking roadking 24026 10월  9 00:03 README.md
drwxrwxr-x  2 roadking roadking  4096 10월  9 00:03 scripts/
-rw-rw-r--  1 roadking roadking   231 10월  9 00:03 setup.py
-rw-rw-r--  1 roadking roadking 46294 10월  9 00:03 slim_walkthrough.ipynb
-rw-rw-r--  1 roadking roadking 20014 10월  9 00:03 train_image_classifier.py
-rw-rw-r--  1 roadking roadking     0 10월  9 00:03 WORKSPACE


# download_and_convert_data.py [./]
# -- download flowers.tgz
# -- extract flowers.tgz
# -- split validation and train set
# -- convert jpeg  to tf.record format
# -- make labels

3. Converting dataset to string format

tf.gfile.FastGFile
- File I/O wrappers without thread locking.

소스에서는 download_and_convert_data.py 를 통해 url 을 통해 dataset 을 다운로드 후,

FastGFile 을 통해 이미지를 string 으로 바로 읽은 후, serialized 객체로 저장하고 있습니다.

download_and_convert_data.py 에 들어있는 FastGFile 을 그래프로 구성하여 실행하고 있습니다.

위와 같이 구성하면 thread 로 동작하여 속도가 빠르지만, 저는 단일 thread 로 opencv 를 통해 읽도록 조금 변경했습니다.

git clone https://github.com/elentail/tensortuto.git 를 통해 아래 코드를 내려 받으실 수 있습니다.

[ 신규 코드 ]

converter.py - 단순히 해당 폴더와 이미지를 파싱하여 string 객체로 저장, label 파싱

label_image.py - test 이미지 평가시에 사용하기 위해 작성한 코드

[ 기존 코드 활용 ]

birds.py - datasets/flowers.py 파일과 동일 , class 수와 train, validation 수만 변경 datasets 로 복사

dataset_factory.py - datasets/dataset_factory.py 파일과 동일, birds 한줄 추가 datasets 로 복사 or 수정



# git clone custom my source,,
# download_andconvert_data 의 역할을 convert.py 로 구성해 봤습니다.
# 아래 github 내 converter.py 참조

roadking@rhinoceros:~/workspace$ git clone https://github.com/elentail/tensortuto.git

roadking@rhinoceros:~/workspace/tensortuto/slim_example$ ll

total 28
drwxrwxr-x 2 roadking roadking 4096 10월 15 21:55 ./
drwxrwxr-x 7 roadking roadking 4096 10월 14 12:58 ../
-rw-rw-r-- 1 roadking roadking 3237 10월 15 21:20 birds.py  #copy to research/slim/datasets /
-rw-rw-r-- 1 roadking roadking 5287 10월 15 21:55 converter.py
-rw-rw-r-- 1 roadking roadking 1966 10월 15 21:22 dataset_factory.py #copy to research/slim/datasets /
-rw-rw-r-- 1 roadking roadking 2969 10월 15 21:22 label_image.py #copy to research/slim/

roadking@rhinoceros:~/workspace/tensortuto/slim_example$ python converter.py \
    --dataset_name=birds \
    --dataset_dir=/home/roadking/Downloads/birds_photos \

converter.py 수행 후 아래와 같이 train, validation, labels 3개의 파일이 신규로 생성됩니다.

[ birds.py ]

[ dataset_factory.py ]

4. Training pre-trained model

checkpoint_exclude_scopes

trainable_scopes



## XX dataset or checkpoint prefix path,,
roadking@rhinoceros:~/workspace/models/research/slim$ TRAIN_DIR=XX/inception_train_1015
roadking@rhinoceros:~/workspace/models/research/slim$ DATASET_DIR=XX/bird_photos
roadking@rhinoceros:~/workspace/models/research/slim$ CHECKPOINT_PATH=XX/inception_v3_model/inception_v3.ckpt
roadking@rhinoceros:~/workspace/models/research/slim$ python train_image_classifier.py \
    --train_dir=${TRAIN_DIR} \
    --dataset_dir=${DATASET_DIR} \
    --dataset_name=birds \
    --dataset_split_name=train \
    --model_name=inception_v3 \
    --checkpoint_path=${CHECKPOINT_PATH} \
    --checkpoint_exclude_scopes=InceptionV3/Logits,InceptionV3/AuxLogits \
    --trainable_scopes=InceptionV3/Logits,InceptionV3/AuxLogits \
    --max_number_of_steps=1000 \
    --save_summaries_secs=600 \
    --save_interval_secs=300 \

...
INFO:tensortuto:Recording summary at step 1.
INFO:tensortuto:global step 10: loss = 1.8428 (0.774 sec/step)
INFO:tensortuto:global step 20: loss = 1.0923 (0.758 sec/step)
INFO:tensortuto:global step 30: loss = 1.1633 (0.777 sec/step)
INFO:tensortuto:global step 40: loss = 0.9142 (0.770 sec/step)
...
INFO:tensorflow:global step 990: loss = 0.3254 (0.767 sec/step)
INFO:tensorflow:global step 1000: loss = 0.3830 (0.769 sec/step)
INFO:tensorflow:Stopping Training.
INFO:tensorflow:Finished training! Saving model to disk.



roadking@rhinoceros:~/workspace/tf-slim/research/slim$ python eval_image_classifier.py \
    --alsologtostderr \
    --checkpoint_path=${TRAIN_DIR} \
    --dataset_dir=${DATASET_DIR} \
    --dataset_name=birds \
    --dataset_split_name=validation \
    --model_name=inception_v3 \
    --batch_size=16
...
ance gains if more memory is available.
INFO:tensorflow:Evaluation [1/4]
INFO:tensorflow:Evaluation [2/4]
INFO:tensorflow:Evaluation [3/4]
INFO:tensorflow:Evaluation [4/4]
2017-10-15 22:22:40.743307: I tensorflow/core/kernels/logging_ops.cc:79] eval/Recall_5[1]
2017-10-15 22:22:40.743451: I tensorflow/core/kernels/logging_ops.cc:79] eval/Accuracy[0.984375]
INFO:tensorflow:Finished evaluation at 2017-10-15-13:22:40



roadking@rhinoceros:~/workspace/tf-slim/research/slim$ python label_image.py \
> --model_name=inception_v3 \
> --model_path=${TRAIN_DIR}/model.ckpt-1000 \
> --data_path=/home/roadking/Downloads/test_images \
> --label_path=${DATASET_DIR}/labels.txt \

> 
=============================================
==== DATA RESULT (confusion matrix)  ========
name			pigeon	chick	sparrow	hawk
test_hawk4.jpg		0	0	0	1
test_chick1.jpg		0	1	0	0
test_hawk2.jpg		0	0	0	1
test_chick4.jpg		0	0.99	0	0.01
test_pigeon2.jpg 	0.9	0	0.09	0
test_hawk1.jpg		0.91	0	0.04	0.05
test_chick2.jpg		0.03	0.96	0	0.01
test_sparrow2.jpg	0	0	1	0
test_sparrow1.jpg	0	0	1	0
test_pigeon4.jpg	0.94	0	0.05	0
test_chick3.jpg		0	1	0	0
test_sparrow3.jpg	0	0	1	0
test_sparrow4.jpg	0	0	1	0
test_pigeon3.jpg	0.99	0	0.01	0
test_pigeon1.jpg	0.12	0	0.88	0
test_hawk3.jpg		0	0	0	1

roadking@rhinoceros:~/workspace/tf-slim/research/slim$

		Model
		TEST_CHICK	_TEST_HAWK	TEST_PIGEON	TEST_SPARROW	RECALL
Human	CHICK	4	0	0	0	1
	HAWK	1	3	0	0	0.75
	PIGEON	0	0	3	1	0.75
	SPARROW	0	0	0	4	1
	PRECISION	0.8	1	1	0.8

	ACCURACY	0.875

[ intro ] google cloud platform

기루광 — Mon, 25 Sep 2017 01:44:10 +0900

* The following describes how to use Google Cloud Platform.

구글 클라우드 플랫폼에 대해서 설치 및 간단한 이용방법 위주로 설명을 진행하겠습니다.
클라우드 플랫폼에서는 VM 구성 및 gpu, cpu 저렴한 가격으로 이용할 수 있습니다.

https://cloud.google.com/ 에 접속하시게 되면 try it free 라는 문구와 함께

1년 동안 유지되는 $ 300 무료 크레딧을 제공 해주고 있습니다. 저도 이 무료 크레딧으로 진행하고 있습니다.

카드 결재 창이 중간에 나오지만, 무료 크레딧 소진 후 자동 진행되지 않음으로 우선 안심하시고 등록 하셔도 됩니다.

1.Google Cloud Platform 가입

https://cloud.google.com

가입이 완료되면 아래와 같이 Google Cloud Platform 왼쪽 상단에 크렛딧 과 무료 기간이 나타나게 됩니다.

저는 이미 가입이 되어 있는 상태라서 약간 다르게 나타나고 있습니다.

Cloud platform 을 사용하는 목적이 여러 경우가 있지만,

저의 경우 집의 컴퓨터가 너무 좋지 않아서 training 용도의 마땅한 컴퓨팅 자원이 없어서 사용해보려고 합니다.

2. Project 생성

클라우드 사용을 위해서는 프로젝트 생성을 우선 진행하셔야 됩니다.

저는 임의로 rk-learning 이란 프로젝트로 만들어 보겠습니다.

3. VM 인스턴스 생성

한 번 생성하게 되면 해당 인스턴스는 수정이 안됩니다. 물론 삭제하시고 새로 만드시면 상관 없습니다.

CPU 2개, HDD 10 GB, OS 는 가장 무난한 우분투 16.04 LTS 로 해당 인스턴스를 생성하겠습니다.

여기서 만드는 순간 부터 요금이 나가기 때문에, 무료 크레딧이긴 하지만,

예상 비용이 얼마나 되는지는 꼭 한번 확인 하시기 바랍니다.

잘못하시면 금방 소진될 수도 있어요

4. VM 인스턴스 시작

디스크와 CPU 를 할당 받긴 하였지만, 크게 사용하지 않으시고 테스트만 해보신다면,

사용 후 인스턴스를 정지 상태로 해 놓으시는 것이 조금은, 크레딧을 덜 소진하는 방법일 듯 싶네요

인스턴스를 시작하게 되면 외부 IP 가 할당이 됩니다.

저는 브라우저 창에서 SSH 로 접속해서 제가 자주 사용하는 user 로 사용자 추가를 해보도록 하겠습니다.

- 브라우저 창에서 열기

: 간단하게 제가 자주 사용하는 계정을 추가하였습니다.

5. SSH 를 통한 접속

다들 아시겠지만, 웹을 통해서 사용할 일은 거의 없단걸 아시꺼에요.

주로 local 환경의 쉘을 통해 접속할 일이 대부분이기 때문에 SSH 등록을 통해서 간단하게 해당 VM에 접속 해보겠습니다.

순서는 아래와 같이 진행하시면 됩니다.

1. ssh-key -t rsa -f <SAVE_PATH> -C <USER_NAME>

2. 생성된 public 키를 메타데이터 - SSH키 에 등록

3. ssh -i <PRIVATE_KEY> USER_NAME@VM_외부_IP

* SSH 공개키는 웹에서 등록해주셔야 합니다.

* 로컬 환경에서 SSH 를 통해 VM 에 접속

- 아래 보시면 username 과 hostname 이 동일하게 보 일 수 있으나 phantoms 가 VM 인스턴스 입니다.

[ CNN ] inception-v3 (tf slim )

기루광 — Wed, 13 Sep 2017 16:49:23 +0900

* Here is an example of using google inception v3 model with tf.slim

TF-Slim 기존의 복잡한 모델을 조금 더 쉽게 정의하고 학습 하기위해 새롭게 나온 API 라고 합니다.

아래 TF-Slim 에 포함되어 있는 CNN 중에 Inception V4 에 대해서 어떻게 사용하는지 설명을 드리고자 합니다.

목표는 V4 모델이었지만 컴퓨팅 자원의 한계로 V3 로 수정하였습니다.

TensorFlow-Slim image classification model library

* https://github.com/tensorflow/models/tree/master/slim

Model	Top 1 Accuracy (%)	Top 5 Accuracy (%)
Inception V1	69.8	89.6
Inception V2	73.9	91.8
Inception V3	78	93.9
Inception V4	80.2	95.2
Inception-ResNet-v2	80.4	95.3
ResNet V1 50	75.2	92.2
ResNet V1 101	76.4	92.9
ResNet V1 152	76.8	93.2
ResNet V2 50^	75.6	92.8
ResNet V2 101^	77	93.7
ResNet V2 152^	77.8	94.1

설치부터 dataset 을 만들고training 와 최종 evaluation 까지 전체 방향에 대해서 수행해 볼 수 있도록

설명드리겠습니다.

Linux 환경에 익숙하지 않으신 분들 위해서 windows 에서 해당 프로젝트를 진행 해보겠습니다.

물론 python 3.6 + tensorflow 1.0▲ 버전은 필수로 설치되어야 있어야 합니다.

1.Installing the TF-slim image models library

github 에서 필요한 model 및 tf-slim 라이브러리를 clone 하도록 하겠습니다.

git clone https://github.com/tensorflow/models/

2.Preparing the datasets

기본적으로 데이터 set은 cifar10, flowers, mnist , imagenet 등을 자동으로 다운로드 받을 수 있지만 ,

자신만의 데이터를 활용하는 방법을 알려드리기 구글에서 새 이미지를 모아봤습니다.

download_and_convert_data.py # 데이터셋 (병아리, 매, 비둘기, 참새 4종 )

3.Converting to TFRecord format

dataset 이 로컬에 저장되어 있다보니 slim 에 있는 예제대로 수행이 어려워 아래 몇가지 수정 사항이 생기네요

* datasets/download_and_convert_birds.py #추가

* download_and_convert_data.py # 수정

<수정 내용 >

< 추가 되어야 할 파일 >

python download_and_convert_data.py ^
  --dataset_name=birds ^
  --dataset_dir=D:\tmp\birds

Training a model from scratch.

컴퓨터 자원의 한계로 이부분은 넘어가고 기존 만들어진 모델을 fine-tuning 해 보도록 하겠습니다,

4.Fine-tuning a model from an existing checkpoint

python train_image_classifier.py \
    --train_dir=${TRAIN_DIR} \
    --dataset_dir=${DATASET_DIR} \
    --dataset_name=flowers \
    --dataset_split_name=train \
    --model_name=inception_v3 \
    --checkpoint_path=${CHECKPOINT_PATH} \
    --checkpoint_exclude_scopes=InceptionV3/Logits,InceptionV3/AuxLogits \
    --trainable_scopes=InceptionV3/Logits,InceptionV3/AuxLogits \
    --max_number_of_steps=2100 \
    --save_summaries_secs=600 \
    --save_interval_secs=300 \
    --batch_size=32   #resource exhausted error 시 size 를 줄여주세요

5.Evaluating performance of a model

python eval_image_classifier.py \
    --alsologtostderr \
    --checkpoint_path=${CHECKPOINT_FILE} \
    --dataset_dir=${DATASET_DIR} \
    --dataset_name=imagenet \
    --dataset_split_name=validation \
    --model_name=inception_v3 \
    --batch_size=16  ## GPU 가 한참 지난 750 Ti 라서 batch size 를 키우면 할당이 안되네요

6.Test sample images from trained model

label_image.py sciprt # 특정 폴더 이미지를 해당 모델로 테스트



import glob
import os,re,sys
import argparse
import importlib
import cv2

import tensorflow as tf
from preprocessing import inception_preprocessing

slim = tf.contrib.slim

# prefix image size
image_size = 299

def run(args):
	data_path = args.data_path
	label_path = args.label_path

	model_path = args.model_path
	model_name = args.model_name
	model_scope = model_name +'_arg_scope'
	
	inception = importlib.import_module('nets.'+model_name)


	with tf.Graph().as_default():
		with slim.arg_scope(getattr(inception,model_scope)()):


			files = glob.glob(data_path+os.path.sep+"*.jpg")
			file_list = list()

			for idx,f in enumerate(files):
				f_string = tf.gfile.FastGFile(f, 'rb').read()
				test_img = tf.image.decode_jpeg(f_string, channels=3)
				processed_image = inception_preprocessing.preprocess_image(test_img, image_size, image_size, is_training=False)
				#processed_images = tf.expand_dims(processed_image, 0)
				file_list.append(os.path.basename(f))
				if(idx == 0):
					processed_images = [processed_image]
				else:
					processed_images.append(processed_image)

			processed_images = tf.stack(processed_images,axis=0)

			with open(label_path,'r') as rdata:
				names = dict()
				for row in rdata:
					strip_row = row.strip()
					split_row = strip_row.split(":")
					if(len(split_row) == 2):
						names[int(split_row[0])]=split_row[1]


			logits, _ = getattr(inception,model_name)(processed_images, num_classes=4, is_training=False)
			probabilities = tf.nn.softmax(logits)

			init_fn = slim.assign_from_checkpoint_fn(model_path, slim.get_model_variables('InceptionV3'))

			with tf.Session() as sess:
				init_fn(sess)

				np_image, probabilities = sess.run([processed_images, probabilities])

				print("\n========  DATA RESULT  =======\n")
				print("filename\t"+"\t".join(names.values()))

				for idx,iter in enumerate(probabilities):
					print(file_list[idx]+'\t' +'\t'.join([str(round(i,2)) for i in iter]))
				

if __name__ == '__main__':

	parser = argparse.ArgumentParser()
	parser.add_argument("--data_path",help="the path to test images")
	parser.add_argument("--model_path")
	parser.add_argument("--model_name")
	parser.add_argument("--label_path")
	if(len(sys.argv) != 5):
		parser.print_help()
		parser.exit()
	args = parser.parse_args()
	run(args)

label 코드를 활용하여 아래 최종 confusion matrix를 구해봤습니다.

전체 학습 보다는 --trainable_scopes=InceptionV3/Logits,InceptionV3/AuxLogits 에서 설정했듯이

Logits 와 AuxLogits layter 만 학습을 진행했는데 생각보다 꽤 괜찮은 결과가 나온 것 같습니다.

[ MLP ] neural network regression

기루광 — Mon, 4 Sep 2017 22:13:52 +0900

* This is an example of regression of the sin function with MLP

(Multi-layer perceptron)

요즘 주변에서는 많이 사용하는 neural network 통해서

regression을 할 수는 없을까라는 잡생각이 들어서 간단하게 만들어 봤습니다.

주어진 범위만 벗어나면 맞지도 않는 것을 왜하지 라고 하시는 답을 아시는 분도 계시겠지만,

심심풀이로 간단하게 정리하고 만든 내용 공유 차원에서 적어 나가겠습니다.

아래 처럼 최종 출력단을 SUM 으로 하여서 알고 있는 답과 비교하면서 학습을 진행하도록 만들었습니다.

cost function 으로는 least square method 방식으로 $\sum_{k=1}^N (predict - correct)^2$ 로 정하였고,

activation function 을 relu 로 하여서 training 을 시도해봤습니다.

■ $sin(x)$ 함수

■ $sin(x)$ neural network regression - relu

처음 하고난 결과는 두둥,,, 뭔가 어설프고 이상한게 보이시죠.

여기에서 제가 한가지 깜빡 했던, 아니 오해했던 내용이 있었네요,

neural network 에서 sigmoid, tanh 함수들은 무조건 사용하지 말고, relu 를 쓰라고 머릿속에 암기되어 있어

regression 문제까지 relu 를 써버렸네요,.

regression 의 특성상 부드럽게 중간 중간을 채워주는 무엇인가가 필요한데,

relu 함수는 그렇게 부드러운 아이는 아니란걸 깜빡했습니다.

regression vs classification

다시 relu 함수를 tanh 나 sigmoid 로 변경해서 training 을 시도했습니다.

역시 예상이 맞았습니다. 부드러운 activation 함수로 바꾸고 나니, 한결 모양이 깔끔해졌습니다.

■ $sin(x)$ neural network regression - tanh

모델로 함수를 쓰지않고, neural network 쓰다보니 역시 학습하지 않은 범위를 넘어가 버리면

값들이 산으로 가버렸네요

supervised learning

아래는 제가 간략하게 구현한 코드 입니다.


# python version 3.6.2
# tensorflow version 1.3.0

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


def make_model(X,layer_shape,**kwargs):

	atv_enum = {'tanh':tf.nn.tanh,'relu':tf.nn.relu,'sigmoid':tf.nn.sigmoid}
	atv_fun = active_type[atv_enum[type]] if 'atv_type' in kwargs else atv_enum['tanh']

	layer = tf.multiply(X,1)
	for idx,size in enumerate(layer_shape[:-1]):
		W = tf.Variable(tf.random_normal([size,layer_shape[idx+1]]))
		b = tf.Variable(tf.random_normal([layer_shape[idx+1]]))
		layer = tf.add(tf.matmul(layer,W),b)

		if(idx != len(layer_shape)-2):
			layer = atv_fun(layer)

	return layer


if __name__ == '__main__':
	x_data = np.linspace(-2*np.pi,2*np.pi, 100).reshape(-1,1)
	y_data = np.sin(x_data)

		
	X = tf.placeholder(tf.float32,name='X')
	Y = tf.placeholder(tf.float32,name='Y')

	# activation function 으로 tanh 사용하였습니다.
	# neural network 구성은 1,5,5,1 로 구성하였습니다.
	model = make_model(X,[1,5,5,1])

	# leat square method 로 cost 함수 정의하였습니다.
	cost = tf.reduce_mean(tf.square(model - Y))
	train_op  = tf.train.AdamOptimizer(learning_rate=0.02).minimize(cost)

	init = tf.global_variables_initializer()
	with tf.Session() as sess:
		sess.run(init)

		for step in range(20000):
			error,_ = sess.run([cost,train_op],feed_dict={X:x_data,Y:y_data})
			if(step % 100 == 0):
				print(step,error)

		# 테스트 데이터를 -4 pi ~ 4 pi 로 구간을 넓혔습니다.
		tx_data = np.linspace(-4*np.pi,4*np.pi, 100).reshape(-1,1)
		predict = sess.run(model,feed_dict={X:tx_data})
		plt.plot(tx_data.flatten(),predict.flatten(),'ro')

		
	plt.plot(x_data.flatten(),y_data.flatten())
	plt.show()

[ RANSAC ] 타원 피팅 (fit ellipse using ransac)

기루광 — Thu, 3 Aug 2017 22:52:57 +0900

또 등장하는 제 마우스 패드와 선물 받은 큐브를 통해서

가려진 타원을 어떻게 복원할지에 대해서 설명을 드리고자 합니다.

일반적으로 circle 과 기존의 ellipse fitting 으로는 아래 마우스 패드의 외각선을 추출해 진행해보면 이상한 결과를 얻을 수 있습니다. 물론,, 아래 마우스 패드의 외각선 정보에 이상한 그림이 겹쳐져 잘못된 정보를 포함해 버렸기 때문이죠 ^^

* fit ellipse using RANSAC (random sample consensu)

RANSAC(random sample consensu) 이란 ?

그림의 마우스 패드를 검출 하려고 보면 외각선 정보에 큐브 외각선이 겹쳐 나타나게 됩니다. 어떻게 하면 이 잘못된 정보 (outlier) 를 제외하고 피팅을 진행 할 수 있을까요? RANSAC은 데이터 집합 중에 일정확률을 가지고 샘플을 추려서 모델에 맞춰보고 해당 샘플 중에 가장 데이터 집합을 많이 대변하는 모델을 추려내는 작업이라고 생각할 수 있습니다.

* 말로 설명하려니 어렵네요. 아래 한번 RANSAC 에 대한 접근 방법을 보시면 바로 이해하실 수 있습니다.

모델 : 타원(rotated ellipse)

데이터 : 마우스 패드 외각선(Inlier) 와 큐브 외각선(outlier)이 포함된 외각선 집합

1. 일정 확률을 가지고 DATA 집합에서 임의 추출 진행

2. 추출진 sample 을 통해서 모델을 예측

3. 예측 모델에서 어느정도의 offset 범위 안에 들어오는 기존보다 클 경우, 해당 (x,y) 값들을 저장

4. 1 - 3 을 N 번 반복 수행

5. 최종 저장된 (X,Y) 값을 통해서 fitting 진행


import cv2
import os,re,sys
import numpy as np


def fit_rotated_ellipse_ransac(data,iter=30,sample_num=10,offset=80.0):

	count_max = 0
	effective_sample = None

	for i in range(iter):
		sample = np.random.choice(len(data), sample_num, replace=False)

		xs = data[sample][:,0].reshape(-1,1)
		ys = data[sample][:,1].reshape(-1,1)

		J = np.mat( np.hstack((xs*ys,ys**2,xs, ys, np.ones_like(xs,dtype=np.float))) )
		Y = np.mat(-1*xs**2)
		P= (J.T * J).I * J.T * Y

		# fitter a*x**2 + b*x*y + c*y**2 + d*x + e*y + f = 0
		a = 1.0; b= P[0,0]; c= P[1,0]; d = P[2,0]; e= P[3,0]; f=P[4,0];
		ellipse_model = lambda x,y : a*x**2 + b*x*y + c*y**2 + d*x + e*y + f

		# threshold 
		ran_sample = np.array([[x,y] for (x,y) in data if np.abs(ellipse_model(x,y)) < offset ])

		if(len(ran_sample) > count_max):
			count_max = len(ran_sample) 
			effective_sample = ran_sample

	return fit_rotated_ellipse(effective_sample)


def fit_rotated_ellipse(data):

	xs = data[:,0].reshape(-1,1) 
	ys = data[:,1].reshape(-1,1)

	J = np.mat( np.hstack((xs*ys,ys**2,xs, ys, np.ones_like(xs,dtype=np.float))) )
	Y = np.mat(-1*xs**2)
	P= (J.T * J).I * J.T * Y

	a = 1.0; b= P[0,0]; c= P[1,0]; d = P[2,0]; e= P[3,0]; f=P[4,0];
	theta = 0.5* np.arctan(b/(a-c))  
	
	cx = (2*c*d - b*e)/(b**2-4*a*c)
	cy = (2*a*e - b*d)/(b**2-4*a*c)

	cu = a*cx**2 + b*cx*cy + c*cy**2 -f
	w= np.sqrt(cu/(a*np.cos(theta)**2 + b* np.cos(theta)*np.sin(theta) + c*np.sin(theta)**2))
	h= np.sqrt(cu/(a*np.sin(theta)**2 - b* np.cos(theta)*np.sin(theta) + c*np.cos(theta)**2))

	ellipse_model = lambda x,y : a*x**2 + b*x*y + c*y**2 + d*x + e*y + f

	error_sum = np.sum([ellipse_model(x,y) for x,y in data])
	print('fitting error = %.3f' % (error_sum))

	return (cx,cy,w,h,theta)

def main(img_path):

	color_list = [(238,0,0),(0,252,124),(142,56,142),(10,20,0),(245,245,245)]

	src = cv2.imread(img_path, cv2.IMREAD_COLOR)
	gray = cv2.cvtColor(src,cv2.COLOR_RGB2GRAY)
	retv, th = cv2.threshold(gray,0,255,cv2.THRESH_BINARY + cv2.THRESH_OTSU) 

	color_th = cv2.cvtColor(th,cv2.COLOR_GRAY2RGB)

	_, contours , _ = cv2.findContours(th,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
	zeros = np.zeros(np.shape(th),dtype=np.uint8)

	for con in contours:
		approx = cv2.approxPolyDP(con, 0.01 * cv2.arcLength(con,True),True)
		area = cv2.contourArea(con)
		if(len(approx) > 10 and area > 30000):

			# fit ellipse
			cx,cy,w,h,theta = fit_rotated_ellipse(con.reshape(-1,2))
			cv2.ellipse(src,(int(cx),int(cy)),(int(w),int(h)),theta*180.0/np.pi,0.0,360.0,color_list[2],2)

			# fit ellipse using ransac
			cx,cy,w,h,theta = fit_rotated_ellipse_ransac(con.reshape(-1,2))
			cv2.ellipse(src,(int(cx),int(cy)),(int(w),int(h)),theta*180.0/np.pi,0.0,360.0,color_list[0],2)

	cv2.imwrite('out.jpg',src)

if __name__ == '__main__':
	if(len(sys.argv) != 2):
		print('usage : {0} <image_abs_path>'.format(sys.argv[0]))
		exit(0)
	main(sys.argv[1])

[ 최소자승법 ] 원, 타원 측정

기루광 — Sun, 23 Jul 2017 00:50:53 +0900

* 이글은 다크프로그래머 님의 - [최소자승법의 이해] 를 읽고 필요한 부분을 정리 및 제가 아는 내용을 추가하였습니다.

http://darkpgmr.tistory.com/56

** Least Square Method, fit ellipse, fit circle, python opencv

가끔 영상을 보면서 원과 타원에 대해서 어떠한 정보를 얻어야 될 때가 있습니다.

외각선 정보보다, 몇개의 파라미터 값(중심, 사이즈 ...)만 알면 표현이 훨씬 간단할 뿐만 아니라 각 물체(원, 타원, 사각) 간의 관계 표현할 때 이만큼 좋은 정보가 없습니다.

그럼 세부적으로 중심, 지름, 장축, 단축 등 이런 정보들은 어떻게 얻을 수 있을 까요?

이럴 때 많이 사용하는 방식이 피팅(fitting)을 사용해서 원의 방정식 또는 타원의 방정식에 얻어진 외각선( x,y 위치 정보)에 데이터가 얼마나 잘 맞는지 넣어보면서 파라미터(장축,단축, 중심) 를 찾는 방향으로 알 수 있습니다.

영상내 어떤 둥그런 물체(object) 를 필터링 해서 크기가 얼마인지 알고 싶을 때,

제가 아끼는 마우스패드가 쇼파 위에 이쁘게 놓여있네요, 이럴 때 이 마우스 패드의 중심과 크기를 알려고 하면 간단히 opencv 의 fitEllipse 함수를 사용해도 큰 문제는 없지만, 기본 개념부터 구현해 보았습니다.

□원의 방정식

답을 찾아가는 방법으로 pesudo inverse 방식을 쓰려고 양함수( f(x,y) = z) 모델을 이용하여 수식을 정리하면 아래와 같이 a,b,c 라는 파라미터를 구할 수 있습니다.

$$ \begin{matrix} { (x-x_1)^2 } + { (y-y_1)^2 } &=& r^2 \\ \\ \Rightarrow x^2+y^2 -2ax - 2by + a^2 + b^2 - r^2 &=& 0 \\ \\ \Rightarrow x^2+y^2 -2ax - 2by + c = 0 &,& c = a^2 + b^2 - r^2 \\ \\ \Rightarrow -2ax - 2by + c &=& -x^2-y^2 \end{matrix} $$

$$ \begin{matrix} \begin{bmatrix} -2x_1& -2y_1& 1\\ \vdots& \vdots&\vdots \\ -2x_n& -2y_n& 1 \end{bmatrix} \begin{bmatrix} a \\ b \\ c \end{bmatrix} = \begin{bmatrix} -x_1^2-y_1^2 \\ \vdots \\ -x_n^2-y_n^2 \end{bmatrix} \\ \\ J =\begin{bmatrix} -2x_1& -2y_1& 1 \\ \vdots& \vdots&\vdots \\ -2x_n& -2y_n& 1 \end{bmatrix}, X = \begin{bmatrix} a \\ b \\ c \end{bmatrix}, Y = \begin{bmatrix} -x_1^2-y_1^2 \\ \vdots \\ -x_n^2-y_n^2 \end{bmatrix} \\ \\ J X = Y \\ X = {(J^T J)}^{-1} J^T Y \\ \\ \end{matrix} $$

□ 타원의 방정식

중심이 0,0 위치에서의 타원의 방정식

$$ \Large \begin{matrix}{ x^2 \over w^2 } + { y^2 \over h^2 } = 1 \end{matrix} $$

원은 회전된 경우(rotated) 문제 없지만, 타원의 경우는 중요하기 때문엥 이를 방정식에 반영 해주어야 합니다.

접근 방법을

1. roatated ellipse (회전이 되어 있는 타원)

2. rotated ellipse 의 회전 각도를 반대로 적용하여 타원의 방정식 폼에 맞게 수정

3. 타원의 중심이 이동 할 수 있음으로 타원의 방정식에 반영

CCW 로 회전이 되어 있다는 가정하에 복원을 위해 CW 방향으로 회전 변환을 적용하겠습니다.

$$ \begin{matrix} \begin{bmatrix} x' \\ y' \end{bmatrix} = \begin{bmatrix} cos(\theta) & sin(\theta) \\ -sin(\theta) & cos(\theta) \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} \\ \\ \Rightarrow x' = cos(\theta)x + sin(\theta)y \\ \Rightarrow y' = -sin(\theta)x + cos(\theta)y \end{matrix} $$

최종적으로 x1,y1 의 중심에 회전이 반영된 방정식입니다.

$$ { (x − x_1 )^2 \over a^2 } + { (y − y_1 )^2 \over b^2} = 1 \\ { [cos(\theta)x + sin(\theta)y − x_1 ]^2 \over a^2 } + { [−sin(\theta)x + cos(\theta)y −y_1]^2 \over b^2} = 1 $$

위 수식을 풀어서 계수를 정리하면 다음과 같습니다. 여기에 간단하게 회전각도에 대해서만 유도를 해보면

( 추가된 내용)

$$ x^2[b^2cos^2(\theta) + a^2sin^2(\theta)] + xy[2b^2sin(\theta)cos(\theta) − 2a^2sin(\theta)cos(\theta)] +y^2[b^2sin^2(\theta)+a^2cos^2(\theta)] +\cdots = a^2b^2 \\ \\ c_1 x^2 + c_2 xy +c_3 y^2 +c_4 x + c_5 y + c6 = 0 $$

$$ \begin{array}{l} { c2 \over (c1 − c3) } = { 2b^2sin\theta cos\theta − 2a^2sin\theta cos\theta \over b^2cos^2\theta + a^2sin^2\theta − b^2cos^2\theta − a^2sin^2\theta} = {2sin\theta cos\theta(b^2 − a^2) \over(cos^2\theta − sin^2\theta)(b^2 − a^2)} \\ = { 2sin\theta cos\theta \over cos^2\theta \; sin^2\theta} = { sin2\theta \over cos 2\theta } = tan2\theta \\ \therefore \theta = {1 \over 2} tan^{−1}({c2 \over {c1 − c3}}) \end{array}$$

아래 코드에 시간이 되시는 분들은 한번 생각해서 유도 해보시면 큰 도움이 되실 것 같아요.

$$ \begin{matrix} ax^2 + bxy + cy^2 + dx + ey + f &=& 0 \\ \\ \Rightarrow x^2 + b'xy + c'y^2 + d'x + e'y + f' &=& 0 \end{matrix} \tag{ Dividing by a} $$

$$\begin{matrix} \begin{bmatrix} x_1y_1& {y_1}^2 & x_1 & y_1 & 1 \\ \\ \vdots & \vdots & \vdots & \vdots & \vdots \\ x_ny_n& {y_n}^2 & x_n & y_n & 1 \end{bmatrix} \begin{bmatrix} b'\\ c'\\ d'\\ e'\\ f' \end{bmatrix} &=& \begin{bmatrix} - {x_1}^2\\ \vdots \\ -{x_n}^2 \end{bmatrix} \\ \end{matrix} \tag{ explicit function form, y=f(x,y)} $$

$$ \begin{matrix} J X &=& Y \\ X &=& {(J^T J)}^{-1} J^T Y \end{matrix} \tag{Pesudo inver }$$

$$ \Large \begin{matrix} \theta = { 1 \over 2 } \tan^{-1}( { b \over a-c }) \\ c_x = { 2cd - be \over b^2 - 4ac } \\ c_y = { 2ae- bd \over b^2 - 4ac } \\ w = \sqrt{ {ac_x^2 + bc_xc_y+ cc_y^2 -f \over a \cos^2\theta + b\cos\theta\sin\theta + c\sin^2\theta } } \\ h = \sqrt{ {ac_x^2 + bc_xc_y+ cc_y^2 -f \over a \sin^2\theta - b\cos\theta\sin\theta + c\cos^2\theta } } \end{matrix} $$

노랑색의 경우 원으로 피팅한 결과 입니다. 당연히 LSM(Least Square Method) 방식으로 맞추다 보니 전체의 모양이 반영이 안되었네요, 파랑색의 경우는 타원의 피팅한 결과 입니다. fitEllipse 함수와 거의 유사하게 나오는 것을 확인 하 실 수 있습니다.


#dependency opencv-python 3.2 
#python version 3.6

import cv2
import os,re,sys
import numpy as np


def fit_circle(data):
	#data [[x1,y],[x2,y2]...]
	xs = data[:,0].reshape(-1,1) 
	ys = data[:,1].reshape(-1,1)

	J = np.mat(np.hstack((-2 * xs,-2 * ys,np.ones_like(xs,dtype=np.float))))
	Y = np.mat(-xs ** 2 - ys ** 2)	
	X = (J.T * J).I * J.T * Y

	cx = X[0,0]
	cy = X[1,0]
	c = X[2,0]
	r = np.sqrt(cx ** 2 + cy ** 2 - c)
	return (cx,cy,r)



def fit_rotated_ellipse(data):

	xs = data[:,0].reshape(-1,1) 
	ys = data[:,1].reshape(-1,1)

	J = np.mat( np.hstack((xs*ys,ys**2,xs, ys, np.ones_like(xs,dtype=np.float))) )
	Y = np.mat(-1*xs**2)
	P= (J.T * J).I * J.T * Y

	a = 1.0; b= P[0,0]; c= P[1,0]; d = P[2,0]; e= P[3,0]; f=P[4,0];
        # To do implementation
        #a,b,c,d,e,f 를 통해 theta, 중심(cx,cy) , 장축(major), 단축(minor) 등을 뽑아 낼 수 있어요

	theta = 0.5* np.arctan(b/(a-c))  
	cx = (2*c*d - b*e)/(b**2-4*a*c)
	cy = (2*a*e - b*d)/(b**2-4*a*c)
	cu = a*cx**2 + b*cx*cy + c*cy**2 -f
	w= np.sqrt(cu/(a*np.cos(theta)**2 + b* np.cos(theta)*np.sin(theta) + c*np.sin(theta)**2))
	h= np.sqrt(cu/(a*np.sin(theta)**2 - b* np.cos(theta)*np.sin(theta) + c*np.cos(theta)**2))

	return (cx,cy,w,h,theta)

def main(img_path):

	color_list = [(238,0,0),(0,252,124),(142,56,142)]

	src = cv2.imread(img_path, cv2.IMREAD_COLOR)
	gray = cv2.cvtColor(src,cv2.COLOR_RGB2GRAY)
	retv, th = cv2.threshold(gray,0,255,cv2.THRESH_BINARY + cv2.THRESH_OTSU) 
	_, contours , _ = cv2.findContours(th,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)

	for con in contours:
		approx = cv2.approxPolyDP(con, 0.01 * cv2.arcLength(con,True),True)
		area = cv2.contourArea(con)
		if(len(approx) > 10 and area > 30000):

			a,b,r = fit_circle(con.reshape(-1,2))
			#cv2.drawContours(src,[con],0,color_list[2],2)
			cv2.circle(src,(int(a),int(b)),int(r),color_list[1])
			cx,cy,w,h,theta = fit_rotated_ellipse(con.reshape(-1,2))
			cv2.ellipse(src,(int(cx),int(cy)),(int(w),int(h)),theta*180.0/np.pi,0.0,360.0,color_list[0],2)

	cv2.imwrite('out.jpg',src)

if __name__ == '__main__':
	if(len(sys.argv) != 2):
		print('usage : {0} < image_abs_path >'.format(sys.argv[0]))
		exit(0)
	main(sys.argv[1])

[ 개발, 설계 ] 실시간 처리 시스템 기본구조

기루광 — Sat, 1 Jul 2017 02:10:34 +0900

* ERD : DA#

* Message Queue : RabbitMQ

* WEB/WAS / DB : Spring Boot / ORACLE

* Application : JAVA or C++

* Statistic : elastic search

아이템이 딱히 없지만, 실시간으로 요청 처리 및 분석 통계 관련된 시스템을 기본부터 설계하여 개발 할 예정입니다.

[ 기본 ] Neural network - feed forward

기루광 — Fri, 30 Jun 2017 22:00:30 +0900

안녕하세요 비오는 장마철에 다시 뵙네요!!

neuron network 중 한 개의 노드를 perceptron 이라고 부릅니다.

입력으로 x1, x2, x3 가 주어졌을 때 이를 이용해서 output 을 나타내는 대표적인 non-linear 모델의 핵심 내용입니다.

perceptron 이 모여서 한 개의 layer를 구성하고 layer 들이 모이면 흔히들 말하는 multi-layer perceptron 이라고 부르는 neural network이 구성됩니다.

그 핵심은 물론 perceptron 이겠죠??

neuron 이 동작하는 원리를 따라서 만들었다고 인공신경(perceptron) 이라고 붙었을 만큼, 동작 원리는 비슷합니다.

우선 x1,x2,x3 라는 입력값이 들어왓을 때 각각의 가중치(w1,w2,w3) 가 곱혀져 값이 나옵니다.

여기서 한가지 생각을 해봅시다. 바늘에 찔렸을 때와 모기가 물렸을 때, 느끼는 정도는 당연히 다르겠죠?

모기에 물렸을 때 분명히 민감한 사람들은 느껴지겠지만, 대부분은 물렸는지도 모르고 지나갈 것입니다.

과연 입력값이 너무 작아서 우리가 느끼지 못하는 것일까요?

입력값이 너무 작으면 아예, 출력값으로 아무것도 전달하지 않는 무언가가 있기 때문입니다.

방금 말한 넘어온 값을 threshold 에 따라 무언가를 동작시킬지 말지 하는 함수들을 activation function 이라고 부릅니다.

이를 표현한 것이 $z=f(u)$ 입니다.

종류는 많지만, 우선적으로 아래 sigmoid, tanh, ReLu(rectified linear Unit) 3가지 정도만 있다면 이해하셔도 무방합니다.

activation function

- sigmoid

- tanh

-ReLu

category	output(activation function)	error function
regression	identity mapping	least square method
binarization	logistic	cross-entrophy
classification	soft-max	cross-entrophy

[ 과제 2 ] Gauss-Newton Method

기루광 — Sat, 24 Jun 2017 13:37:28 +0900

똑똑한 후배에게 Gradient descent 를 설명해 주었더니, learning rate 구현을 빼먹어서 error function 이 발산하는 쪽으로 가버렸네요..

최적화 방법 중에 그럼, learning rate 없이 할 수 있는 방법을 없을 까요?

*Gauss-Newton Method 설명을 위해서 Newton's Method 에 대한 설명이 필수적이라, 먼저 간략히 설명 뒤에 Gauss-Newton Method에 진행하겠습니다.

Newton's method

Wikipedia : https://en.wikipedia.org/wiki/Newton%27s_method

- 임의의 시작점에서 함수의 미분을 이용하여 1차 식으로 근사하여 0과 만나는 다음의 x 값으로 x를 업데이트 진행하는 방식입니다. 아래 보시면 gradient descent 와 다르게 learning rate(=step size) 가 보이지 않는 것을 알 수 있습니다.

$f : [ a , b] \rightarrow \mathbb{R} $

a,b 범위 안에서 미분가능한 함수 $f(x) = 0$ 근을 반복적인 방법을 통해 찾는 과정 입니다.

기울기 $f'(x_1)$ 와 한 점 $(x_1,f(x_1))$ 만 알고 있다면 아래와 같이 다음 $x$ 값을 업데이트 할 수 있습니다.

$$ \begin{matrix} f'(x_1) , \quad [ x_1, f(x_1) ] &\rightarrow& f'(x_1)(x-x_1) - f(x_1) = 0 \\ x &=& x_1 - { f(x_1) \over f'(x_1) } \end{matrix} $$

우리가 원하는 오차함수가 운이 좋게 E(x) = 0 이란 값이 나올 수 있지만, 현실적으로 E(x) = 0 이란 값이 나올 수 없는 경우가 더 많습니다. least square method 방법으로 오차함수를 정의 했기 때문에, 잠깐 생각을 바꿔서 미분값이 0이 되는 경우를 찾으면, 이는 분명히 최소, 최대 일 경우 둘중에 한가지로 생각해 볼 수있습니다. 여기에 더해서 오차함수의 특성상 최대값이 나오는 형태가 어려움으로 대부분 최소로 생각을 정리 해볼 수 있습니다.

다시 한번 설명 드리면 E(x) = 0 의 경우가 존재 하지 않을 수 있기 때문에, E'(x) = 0 으로 문제를 바꿔서 수식을 정리한 것이 아래 내용입니다.

$$ \begin{matrix} x_{t+1} &=& &x_t&- &{ E'(x_t) \over E''( x_t) }& \\ \rightarrow \boldsymbol{ p_{t+1} } &=& &\boldsymbol{ p_t }& - &H_E(\boldsymbol{ p_t })^{-1} \nabla E(\boldsymbol{ p_t })& \\ \end{matrix} $$

한 단계 더 나아가 matrix 형태로 수식을 정리하면 Gradient, Jacobian 에 이어서 Hessian 이란 무시무시한 놈이 나타납니다. Hessian 의 경우, 2차 미분이라고 간단히 생각을 정리하고 넘어가도록 하겠습니다. Hessian 을 직접 구하지 않고 근사하는 방식이 바로 Gauss-Newton Method 방식이죠!!

저희가 구현할 내용도 바로 이 Gauss-Newton Method 입니다. 여기까지 왜 Gauss-Newton-Method가 필요한지 설명을 드렸는데,, Hessian 구하기가 그렇게 쉽지 않기 때문이죠!!

Gauss-Newton method

- 접근 방법은 taylor series 를 통해 residual 을 1차 미분 까지만 전개하여 근사화 하여 이를 통해서 파라미터를 업데이트 하겠다는방법이다. 아래 우선 수식을 먼저 공유드리고 세부적인 내용인 차후 업데이트 하도록 하겠습니다. 관심 있으신 분들은 아래 파라미터 업데이트 방식 간단히 python 코드로 구현 해보시기 바랍니다.

여기서의 핵심은 Hessian 연산을 피하기 위해 테일러 급수 를 통해서 residual 을 근사화하고 이를 통해서 파라미터를 업데이트를 진행하겠다는 방향입니다. 이부분만은 꼭 기억해두시 바래요.

$$ \begin{matrix} \text{Taylor series} \\ f(x) &=& f(a) + f'(a)(x-a) +{ f''(a) \over 2! }(x-a)^2 \cdots { f^{(n)}(a) \over n! }(x-a)^n &=& \sum_{n=0}^\infty { f^{(n)}(x-a) \over n!}(x-a)^n \\ \text{approximation} \\ \boldsymbol{r}(\boldsymbol{p}) &\approx& \boldsymbol{r}(\boldsymbol{p_t}) + J_r(\boldsymbol{p_t}) \boldsymbol{r}(\boldsymbol{p - p_t}) \\ \end{matrix} $$

$$ \large \begin{matrix} E(\boldsymbol{p}) = \sum_{i=1}^n { [y_i - f(x_i,\boldsymbol{p})) ] }^2 = \sum_{i=1}^n {r_i}^2 = \boldsymbol{r^T r} \\ \\ \\ { \partial E(\boldsymbol{p}) \over \partial \boldsymbol{p} } = { \partial \boldsymbol{r^T r} \over \partial \boldsymbol{p} } = 2\boldsymbol{r^T} { \partial \boldsymbol{r} \over \partial \boldsymbol{p} } \\ \\ \\ \therefore \boldsymbol{p_{t+1}} = \boldsymbol{p_t} - (J_r^T(\boldsymbol{p_t})J_r(\boldsymbol{p_t}) )^{-1}J_r^T(\boldsymbol{p_t})\boldsymbol{r(p_t)} \end{matrix} $$

**아래 코드를 한번 구현해 보시면 생각이 정리 될 수 있어요

- 그림을 보시면 단 1번의 iteration 으로 아래와 답에 유사하게 나왔습니다. 엄청나죠,,!!

(기존 naive gradient descent 또는 momentum 에 비교해도 수렴이 확실히 빠르네요)


import numpy as np
import numdifftools as nd
import matplotlib.pyplot as plt

def optimizer_gauss_newton(xdata,ydata,max_iter,epsilon=0.0):

    aidx = 0;
    f, axarr = plt.subplots(2,2)
    axarr[0,0].plot(xdata,ydata,'ro')
    axarr[0,0].set_title('original')

    #model 2th-polynomial: ax^2 + bx +c
    #pt = np.random.rand(3,1)
    pt = np.zeros((3,1))

    r_fun = lambda p:(ydata -(p[0,0]*xdata**2+p[1,0]*xdata+p[2,0]))
    Jrp = nd.Jacobian(r_fun)

    for i in range(1,max_iter):
        r = ydata -(pt[0,0]*xdata**2+pt[1,0]*xdata+pt[2,0])

        pt = pt - np.dot(np.linalg.pinv(Jrp(pt)),r)
        error = np.sum(np.absolute(r))
        if(i%1 == 0 or i == max_iter -1):
            print('iter=[{0}], error={1}'.format(i,round(error,4)))
            aidx +=1
            axarr[int(aidx/2),aidx%2].plot(xdata,ydata,'ro')
            axarr[int(aidx/2),aidx%2].plot(xdata,pt[0,0]*xdata**2+pt[1,0]*xdata+pt[2,0])
            axarr[int(aidx/2),aidx%2].set_title('iter[{0}]'.format(i))
    print(pt)
    plt.setp([a.get_xticklabels() for a in axarr[0, :]], visible=False)
    plt.setp([a.get_yticklabels() for a in axarr[:, 1]], visible=False)
    plt.show()

if __name__ == '__main__':
    xdata = np.reshape(np.arange(0,1,0.1),(-1,1))
    ydata = 2.1*xdata**2 -1.5*xdata + 0.5
    optimizer_gauss_newton(xdata,ydata,4)

함수 최적화 - Gradient Descent 에 대해서

기루광 — Sun, 18 Jun 2017 11:54:04 +0900

Gradient Descent 방법 중 업데이트 시 데이터를 사용하는 기준에 따른 분류

Batch Gradient Descent
Stochastic Gradient Descent
Mini-batch Gradient Descent

$$ \large \begin{matrix} \\ \vec p_{t+1} = \vec p_t - \lambda \nabla E(\vec p_t) \tag {1} \end{matrix} \\ \\ \lambda \text{ : learning rate } $$

우선 Batch 경우는 $\vec p_{t+1}$ 업데이트를 할때 주어진 학습 데이터를 전부 사용하여 진행하기 때문에 방향에 대해서는 정확할 수 있지만, 계산량 면에서는 너무 많을 수 있습니다. 다음 경우로 Stochastic 경우는 하나의 데이터 $( x_i , y_i )$ 를 이용하여 업데이트를 진행하기 때문에 속도면에서는 빠를 순 있지만, 정확하지 않을 수도 있습니다. 따라서 현재 가장 많이 사용하는 Mini-Batch 는 전체 학습 데이터 중 임의로 N 개의 sample을 추려서 N 개의 데이터를 통해 업데이틀 진행하기 때문에, Batch 와 Stochastic 을 합쳐 놓았다고 생각 하시면 될 것 같아요.

제가 사용할 예제는 학습 데이터가 많지 않기 때문에 Batch Gradient Descent 위주로 설명하면서 진행하도록 할께요.

Gradient Descent Algorithm 종류

Naive Gradient Descent
Momentum
Nestrov Gradient
Adagrad
Adadelta
RMSprop
Adam

Naive Gradient Descent

: 식 1로 정의가 됩니다.

Momentum

관성이라는 말이 딱 들어 맞을 것 같습니다. 이전 업데이트에서 parameter 값이 최적화를 통해 가고 있는 방향에 대해서, 즉 이전 업데이트시 가고 있는 방향에 대한 가중치를 주면서, 진행하는 방식입니다. 느낌이 와닿지 않으면, 관성이란 말을 까먹으시면 안됩니다. 제가 지금 전력으로 달리다가 갑자기 뒤로 돌면, 달리던 방향으로 넘어가겠죠..?

$$ \large \begin{matrix} \vec m_t &=& \gamma \vec m_{t-1} + \nabla E(\vec p_t) \\ \vec p_{t+1} &=& \vec p_t - \vec m_t \tag {2} \end{matrix} \\ \\ \\ \gamma \text{ : momentum rate } $$


import numpy as np
import numdifftools as nd
import matplotlib.pyplot as plt


def optimizer_momentum(xdata,ydata,learning_rate,max_iter,momentum=0.9):

       # implementation moment gradient

동일한 learning rate 로 Gradient descent 와 momentum 결과를 살펴 볼까요? 아래 그림을 보시면, momentum 알고리즘을 왜 사용해야 되는지 알 수 있어요, 단순한 gradient descent 보다 수렴속도가 엄청나네요!!

< Gradient Descent : iteration >

< Momentum : iteration >

Adagrad ( Adaptive Gradient )

- 업데이트 컨셉을 많이 최적화 된 parameter 는 learning rate 를 줄이고 최적화가 덜 된 parameter 들은 learning rate 를 더 높게 가져가 보는건 어떨 까요?, 최적화가 많이 되고 안되었다는 기준은 무엇인지 고민할 필요가 있어 보이네요,, 파라미터가 초기값에서 많이 변했다면 ,이 값은 최적화가 더 되었다고 생각해보는 컨셉이 Adagrad 의 핵심 입니다. 아래 수식을 보면 parameter 마다 learning rate 이 다르다는 것이 보이시죠? 한가지 아쉬운 점이 있다면 $g_1 , g_2, \cdots , g_m $ 값이 항상 커지는 방향이라는 거죠,, 한 번 이를 통해서 학습을 진행 해보도록 하겠습니다.

$$ \large \begin{matrix}\ \vec g_t &=& \vec g_{t-1} + \nabla E(\vec p_t) \odot \nabla E(\vec p_t) &=& \begin{bmatrix} g_1 \\ g_2 \\ \vdots \\ g_m \end{bmatrix}\\ \\ \\ \vec p_{t+1} &=& \vec p_t - { \lambda \over \sqrt{ \vec g_t + \epsilon } } \odot \nabla E(\vec p_t) &=& \vec p_t - \lambda \begin{bmatrix} { 1 \over \sqrt {g_1 + \epsilon } } \\ {1 \over \sqrt {g_2 + \epsilon } } \\ \vdots \\ {1 \over \sqrt {g_m + \epsilon } } \end{bmatrix} \odot \nabla E(\vec p_t) \end{matrix} \\ \\ \\ \odot \text{ : element wise multiplication } \quad \lambda \text{ : learning rate} \quad \epsilon \ : \ 10^{-4} \sim 10^{-8} $$

[ 과제 1 ] Gradient Descent

기루광 — Fri, 16 Jun 2017 16:59:17 +0900

써먹을 일 없다고 내려두었던 내용들이 누군가에게 도움이 된다면,

Linear regression 에 대해서는 closed-form 인 pseudo inverse 존재하기 때문에 대부분은 gradient descent 방식을 시도 조차 하지 않습니다. 하지만, nonlinear 로 넘어가면 꽤나 간단하면서 직관적인 최적화 방법이기 때문에 많이 사용하고 있습니다.

제가 이번에 다룰 내용은 polynomial 함수 (y = ax^2 + bx + c), 2차 함수에 대해서 gradient descent 방법을 통해 최적화 하는 방법을 다루도록 하겠습니다. 시작에 앞서 기초적인 내용과 수식을 설명 드리겠습니다.

수식 전개에 앞서서 저랑 약속 한개만 할께요, 모든 벡터는 열벡터 이고 위와 같이 열벡터를 볼드체로 표시하도록 하겠습니다. 혼동하지 마세요~

회사 선배가 갑자기 와서 저에게 데이터를 던져주고 입력으로 말도 안되는 데이터를 주고

"입력이 들어가면 출력이 이런데, 함수를 찾아서 알려줘, 그런데 예전에 이게 2차 함수였던 것 같은데,,"

모든 힌트가 다 나온 것 같습니다. 주어진 데이터를 관찰 데이터 라고 가정하면 입력값과 출력값 pair 가 n 개 주었졌을 것이고 가정으로는 2차 polynomial 함수 라는 것도 알 수 있었네요. 이를 통해서 오차함수 를 구하면 위와 같이 matrix form 까지 전개가 가능합니다.

이번 주제가 바로 gradient descent 방식을 통한 함수 최적화 라고 말씀드렸죠??

최적화 방법으로 gradient descent 방식을 사용하려면, Gradient 와 Jacobian 이란 이상한 용어와 마주해야 됩니다.

둘다 정말 간단히 설명 드리면, 미분입니다. Gradient 경우는 multi-variable scalar 함수 에 대해서 각 variable 로 미분을 한 것이고 Jacobian 의 경우는 이를 한단계 더 확장한 multi-variable vector 함수에 대한 미분이라고 생각하시면 됩니다.

다 잊어도 상관없지만, 정말 중요한 것은 둘다 미분이란 것입니다.

아래와 같이 Gradient Descent 방법을 통해서 파라미터를 업데이 해보도록 하겠습니다.

사용코드는 python 을 통해서 전개 하도록 하겠습니다.

예전에 , 후배에게 이 내용을 설명해줄 때 넌지시 Jacobian 은 내가 코딩해줄께 라고 생색을 냈는데, 실제 linear regression 에 대한 Jacobian 은 나중에 아시면 너무 쉽습니다. 아니. 큰 의미가 없다고 봐도,,,

학습 데이터 에 대해서 Gradient Descent 방식을 통해서 예측 값이 점점 다가가는 것을 확인 할 수 있습니다.

아래 python 코드를 완성해 보시면 충분히 어렵지 않다는 것을 알 수 있습니다. Gradient descent 을 사용해서 $f(x) = ax^2 + bx +c$ 를 학습해 보는 코드입니다.


#!/home/roadking/anaconda3/bin/python
import numpy as np
import numdifftools as nd
import matplotlib.pyplot as plt


def optimizer_gradient(xdata,ydata,learning_rate,max_iter,epsilon=0.0):

    aidx = 0;
    f, axarr = plt.subplots(2,2)
    axarr[0,0].plot(xdata,ydata,'ro')
    axarr[0,0].set_title('original')

    #model 2th-polynomial: ax^2 + bx +c
    #pt = np.random.rand(3,1)
    pt = np.zeros((3,1))

    r_fun = lambda p:(ydata -(p[0,0]*xdata**2+p[1,0]*xdata+p[2,0]))
    Jrp = nd.Jacobian(r_fun)

    for i in range(1,max_iter):
        r = ydata -(pt[0,0]*xdata**2+pt[1,0]*xdata+pt[2,0])
        pt = pt - 2*learning_rate*np.transpose(Jrp(pt)).dot(r)
        error = np.sum(np.absolute(r))
        if(i%500 == 0 or i == max_iter -1):
            print('iter=[{0}], error={1}'.format(i,round(error,4)))
            aidx +=1
            axarr[int(aidx/2),aidx%2].plot(xdata,ydata,'ro')
            axarr[int(aidx/2),aidx%2].plot(xdata,pt[0,0]*xdata**2+pt[1,0]*xdata+pt[2,0])
            axarr[int(aidx/2),aidx%2].set_title('iter[{0}]'.format(i))
    print(pt)
    plt.setp([a.get_xticklabels() for a in axarr[0, :]], visible=False)
    plt.setp([a.get_yticklabels() for a in axarr[:, 1]], visible=False)
    plt.show()

if __name__ == '__main__':
    xdata = np.reshape(np.arange(0,1,0.1),(-1,1))
    ydata = 2.1*xdata**2 -1.5*xdata + 0.5
    optimizer_gradient(xdata,ydata,0.05,1500)

머신러닝 기초

기루광 — Wed, 17 May 2017 23:25:07 +0900

요즘은 어느 곳이든 머신 러닝이라는 말을 많이 사용합니다.

더 나아가 딥러닝이란 말도 사용하는데 정말 머신러닝이 무엇을까요?

대부분 사람은 아래 x와 그 결과가 나온 표를 보고는 f(10) 이 무엇이 될지 단박에 알아 냅니다.

어떻게 이런 일이 일어나고 있는 것일까요?

1. 입력과 출력의 데이터를 쭈욱 본다.

2. 출력에 연관된 함수(모델)을 몇가지 생각해본다.

3. 잘 들어맞는 함수를 찾아낸다.

4. 그 함수에 최종 10 값을 넣어 그 결과를 도출한다.

위 예를 가지고 용어를 정리해보도록 하겠습니다.

정답지가 주어져 있는 경우를 supervised 그렇지 않은 경우를 unsupervised 라고 합니다.

unsupervised 우선 논외로 하고 위에처럼 정답지 데이터가 주어진 경우를 머신러닝에서는 supervised learning 이라고 합니다. 회사에서 많이 사용하는 엑셀에서의 추세선을 그리는 자체가 바로 supervised learning 이라고 말할 수 있습니다.

1. 입력과 출력의 데이터를 쭈욱 본다. --- train data

2. 출력에 연관된 함수(모델)을 몇가지 생각해본다. -- exponential , power ?

3. 잘 들어맞는 함수를 찾아낸다. -- power 가 더 잘 맞네? y=x^2

4. 그 함수에 최종 10 값을 넣어 그 결과를 도출한다. - 10^2 = 100

저희는 이미 실생활 뿐만 아니라 엑셀을 통해 많은 머신러닝을 이뤄내고 있었네요,,

이제 조금 더 머신러닝에 맞는 용어로 바꿔서 설명 하도록 하겠습니다.

1. 입력과 출력의 데이터 - train data ( 관찰된 데이터, 최종 함수를 찾기 위해 우리에게 주어진 값 )

2. 함수(모델) - (크게 보면 classification /regression 모델로 분류가능 한데, 주어진건 regression(함수) 모델 )

3. 잘 들어맞는 함수를 찾아낸다. - (찾는 방법 fitting, optimization, 잘들어 맞는지 cost,error,residual)

4. 결과를 예측 (prediction) - 10^2 = 100

주어진 train data 를 통해서 분류하는 모델(classification) 또는 함수모델(regression) 인지 결정하여 모델을 가정(hypothesis) 합니다. 주어진 train data를 통해서 hypothesis 가 맞는지 하나씩 넣어보면서 hypothesis 값과 train data 들간의 차이를 계산합니다(cost, error, residual ...). 이과정을 통해서 hypothesis 의 파라미터( y =a x^2, a:parameter) 를 바꿔가면서 hypothesis 와 train data 의 차이가 최소가 되는 파라미터를 선정하게 됩니다. 이를 통해 최종 결정된 함수에 우리가 원하는 결과를 prediction 할 수 있습니다.

Spring boot 사전준비

기루광 — Wed, 17 May 2017 22:30:03 +0900

Web 을 하기에 여러종류의 있지만, Java 계열의 spring boot 에 대해서 포스트를 진행하도록 하겠습니다.

우선 가장 중요한 것은 개발 환경을 잘 구성하는 것 입니다.

1. Eclipse.org 접속 - Download

2. Download Packages - 설치파일로 받고 싶은신 분은 바로 Download 64 Bit 로 설치하시면 됩니다.

(제 경우는 binary 실행파일로 설치하고 하는 경우 입니다.)

3. eclipse-jee-neon-*.zip 파일을 다운로드 하여 적당한 곳에 압축을 풀고 eclipse 실행

4. eclipse market place 에서 Spring 으로 검색하셔서 Spring IDE 최신 버전을 인스톨

5. New Project 에서 Spring Spring Starter 프로젝트를 추가

6. Type 의 경우 메이븐과 Gradle 중 원하는 build tool에 맞게 아래 정보를 작성

7. 단순 DB 연동을 제외하고 Web 과 View 를 구성하기 위해 Thymeleaf 와 Web을 선택하여 생성

8. 최종 프로젝트 생성 후 explorer

* static: css, js, fonts 등 정적 요소 위치

* template : thyemleaf 에서 실행될 html 이 위치하게될 장소

* build.gradle : gradle 용 build 설정 파일 (maven 경우 pom.xml 로 생성됨)

행렬 연산 (Matrix C)

기루광 — Mon, 8 May 2017 00:09:06 +0900

이 내용은 다크 프로그래머님의 http://darkpgmr.tistory.com/141 (벡터 미분과 행렬 미분) 내용을 보고 내용을 정리 한 수준입니다. 다크 프로그래머님의 내용과 같이 추가로 https://en.wikipedia.org/wiki/Matrix_calculus 위키피디아 내용도 참조하였습니다.

학부 시절에 배웠던 gradient 가 머신러닝을 하면서 이렇게 와 닿을 줄 몰랐습니다. x1, x2, x3 독립 변수를 가지는 f(x) 에 대하여 gradient 를 취하면 각 독립변수에 대한 미분 값을 구할 수 있습니다. ( 스칼라 미분을 벡터로 확장). 다음에 배우겠지만, vector 를 vector 로 미분하게 되면 jacobian 까지 확장 될 수 있습니다.

이제 추가로 matrix(행렬)과 vector, scala 에 대해서 일반적인 미분식을 사용하면 아래와 같이 정리 할 수 있습니다.

다크프로그래님의 말씀처럼, 정리하는 폼에 따라서 Numerator-layout notation(분자 우선 표현), Denominator-layout notation(분모 우선 표현) 2가지 종류에 따라서 numerator 은 행벡터로 , denominator 는 열벡터로 표현 할 수 있습니다.단순 표시하는 notation 에 따라 표현식이 달라질 수 있으나, 결과적으로 transpose 를 하면 서로 같은 내용이라는 걸 알 수 있습니다. 저도 혼동이 안가고자 모든 표현을 numerator 분자우선 표현으로 식을 정리하도록 하겠습니다.

* 볼드체 경우는 열벡터 (column vector)

* 대문자 경우는 행렬 (matrix)

	Scala y	Vector y (size m)	Matrix Y (size m x n)
Scala x
Vector x (size n)
Matrix X (size m x n)

Visitor pattern (c++)

기루광 — Sun, 7 May 2017 19:01:22 +0900

Visitor pattern 은 객체 내부에 있는 알고리즘을 분리 시키는 패턴입니다. 알고리즘을 분리시켜 놓으면 구조를 수정하지 않아도 새로운 기능(알고리즘)을 만들기 쉽기 때문입니다. 저도 공부하면서 와닿지 않는 패턴이었고, 다른 분들도 이해하기 어려운 패턴 중에 하나라고 말씀드리고 싶습니다.

제가 살고 있는 아파트를 말씀드리면, 소독하시는 여사님, 물건을 배달해주시는 택배기사님, 술한잔 하러 놀러오는 친구들이 찾아옵니다. 이 뜬금없는 한 문장에 visitor pattern 의 핵심 내용이 들어있습니다. 아파트라는 정해진 구조(structure)에 많을 일들을 해 주시는 분(visitor)이 오셔서, 문을 열어주면(accept) 많은 일들을 할 수 있게합니다.(algorithm, operation)

오늘 저녁 새로 생긴 치킨집에 배달 시켜서 새로운 맛을 느껴봐야 겠네요.
(* 신규 visitor 생성 으로 새로운 기능 추가)

< Visitor Pattern >

그런데 과연 이 패턴을 언제 어떻게 사용해야 될까요?

File System을 보게되면 정해진 구조(file,directory)로 이루어져 있습니다. 중요한 파일을 백업(압축)하려면 하위 디렉토리 node로 옮겨가면서 파일들을 압축해야 합니다. 뿐만 아니라 검색도 같은 방식으로 정해진 구조를 방문 후 검색이란 알고리즘만 추가하면 가능할 것 같습니다. 아래 예를 가지고 실제 코드로 구현해 보도록 하겠습니다.(진행)

< 파일 시스템에 적용된 Visitor Pattern >

Strategy pattern (c++)

기루광 — Fri, 5 May 2017 14:50:29 +0900

Strategy Pattern 의 컨셉은 어떤 전략(algorithm or strategy) 을 추상화 하여 전략을 쉽게 변경하는데 의미를 둘 수 있습니다. 대부분 이런 말을 하면 크게 와닿지가 않아서 디자인 패턴의 최고 할 수 있는 스타크래프트 게임에 비유해서 말하곤 합니다.

어떤 유닛이든 기본적으로 전략(algorithm, strategy)를 공통으로 뽑아보면, 여러개가 있지만 우선적으로 움직이거나 공격할 수 있는 공통 전략을 추출할 수있습니다.

Spring boot 공부중

기루광 — Mon, 1 May 2017 17:48:48 +0900

웹이라고는 html, css, javascript 가 어떤 의미인지도 몰랐던 시절에 무조건 웹을 개발하라고 해서 무턱대고 만들었던 기억이 엊그제 같습니다. 혼자 구글과 싸움을 벌이면서 온갖 xml 이 넘쳐나던 spring mvc, 지금 생각해봐도 개발자의 능력보다는 구글링의 스킬만 키우면 엄청나겠구나! 를 느끼게 합니다. 머신러닝 관련해서 한 동안 C++ 사용해와서 기억속에서 지워져 가는 웹을 되살림겸, xml 에 지쳐서 spring boot 로 간단하게 만들었던 prototype 을 통해서 웹에 대해서 포스팅 하도록 하겠습니다.

<소스코드 : github >

https://github.com/elentail/springboot.git (spring boot 1.3.1 버전 -- > 1.5 로 전환 예정)

* angularjs, bootstrap, google chart etc ... (front-end library 사용)

** 저도 기억이 가물가물해서 하나씩 내용을 보면서 정리하도록 하겠습니다.

@Configuration : 자바 기반 설정임을 알려주는 annotation

@EnableAutoConfiguration : sub-package에 있는 @Entity 클래스들을 scan

@ComponentScan : xml의 <context:component-scan>

--> @SpringBootApplication

** view resolver

JSP

thymeleaf

velocity -- deprecated (spring boot 1.5)

* Spring boot web

Dispatcher Servlet : 클라이언트로 부터 오는 신호는 무조건 dispatcher를 최우선으로 진행

Handler Mapper : 흔히 말하는 GET,DELETE,POST,PUT 등 뿐만 아니라 URI REST 처리하는 모듈

Controller : Mapper를 통해 들어온 request 를 어떻게 처리할지 결정하는 모듈

Model : Custom model을 만들 수 있고 또는, DB를 붙여 정보를 가져올 수 있도록 하는 모듈

View Resolver : 어떤 dialect 를 사용할지 결정(JSP, thymeleaf, groovy ... )

View : 최종 클라이언트로 전송되는 html 형태의 view

아래 내용 또한 공부해서 시간이 되는데로 업데이트 예정입니다.

* Spring actor

* Spring cache

* Spring validation

* Spring batch

* Spring scheduler

* Spring mongodb

* Spring security

선형회귀(linear regression)-최소자승법

기루광 — Wed, 26 Apr 2017 23:18:10 +0900

이글은 순수하게 다크프로그래머 님의 기계학습 중

함수 최정확 기법정리 부분을 인용하여, 내용은 정리한 수준입니다.

http://darkpgmr.tistory.com/142

*residual 이 최소가 되는 일반적인 최소자승법

* parameter 에 linear 한 모델의 경우 아래와 같이 수식 유도 가능합니다. -> Ap

* 선형회귀(linear-regression) 경우 pseudo inverse 를 통해 특정해를 구할 수 있습니다.

*일반적인 해를 구하는 방식으로 아래 4가지 방식에 대해서 추가 설명 드리겠습니다.

1. Gradient Descent

2. Newton-raphson

3. Gauss-Newton

4. Levenberg_marquardt

Singleton pattern (c++)

기루광 — Wed, 26 Apr 2017 23:06:35 +0900

싱글톤 패턴(Singleton Pattern)

객체를 사용할 때 매번 생성하지 않고 딱 한 번의 생성을 통해 이를 재활용 하는 패턴입니다.

객체 생성 횟수를 줄여서 메모리를 절약가능하긴 하지만, 요즘과 같이 메모리가 넘쳐나는 시대에 크게 와닿지 않습니다.

다른 이유는 없을까요? 다들 사무실에서 프린터를 사용해본 경험이 있을 것 입니다. 네트워크로 연결해서 여러사람들이 쓸 수 있게 연결되어 있습니다. 어떻게 사용되는지 자세하세 살펴 볼까요

사용자1

사용자2

사용자3 ----▷ TCP/IP ----▷ 프린터(요청된 작업 한개를 출력)

...

사용자 N

프린터는 사용자1, 2, 3 으로부터 작업을 언제든지 받을 수 있습니다. 사용자1이 요청하자마자 사용자2 가 다른 작업을 요청하면 똑똑한 프린터는 작업큐 라는 공간을 만들어서 순차적으로 처리를 합니다. 그럼 이런 큐를 2개 이상이 생성한다면 다들 글자 한줄 짜리 프린트 물을 받아 볼지도 모릅니다. 보통은 시스템 자원관리, 정보 등을 관리하는 thread pool, work pool, connection pool 은 싱클톤패턴을 사용하고 있답니다.





#include <iostream>

class singleton
{

	// 포인터를 통해 딱 한개의 instance 를 관리
	static singleton* _instance;
	singleton() {};

public:
	// c++11 style : copy constructor 호출 되지 못하도록
	singleton(const singleton& other) = delete;
	// singleton 객체 생성
	static singleton* get_instance()
	{
		if (_instance == nullptr)
		{
			_instance = new singleton();
		}
		return _instance;
	}

	// singletone 객체 해제
	static void release_instance() {
		if (_instance) {
			delete _instance;
			_instance = nullptr;
		}
	}
};
// 기본 _instance 값을 nullptr 로 설정
singleton* singleton::_instance = nullptr;

int main()
{
	singleton* instance = singleton::get_instance();
	instance->release_instance();
	return 0;
}

아 이제 완성이 되었네요. 정말로 이제 singleton 객체를 통해 pool 관리도 하고 멋진 일들을 해낼 수 있다고 믿는 순간, 한가지 의문이 생깁니다. 사용자1, 2가 동시에 생성해달라고 하면 어떤 일이 일어 날까요? singleton 객체가 2번이나 생성 될 수 있어 알지 못하게 memory leakage 가 발생해 버립니다. 몇 백번쯤이야 상관없지만 수십만번 된다고 하면 끔찍일이 생기겠네요.

thread-safe singleton 을 한번 만들어보겠습니다. c++11 로 넘어오면서 많인 기능들이 생겼는데 그중 한개가 #include <mutex>에 들어있는 mutex 입니다. 이를 통해 손쉽게 thread 동기화가 가능합니다.





#include <mutex>
class singleton
{

	static singleton* _instance;
	// thread safe 보장하려면 mutex가 필요해
	static std::mutex _mutex;
	singleton() {};

public:
	singleton(const singleton& other) = delete;
	static singleton* get_instance()
	{
		if (_instance == nullptr)
		{
			// lock 을 걸면 다른 thread는 기다려요
			_mutex.lock();
			_instance = new singleton();
			_mutex.unlock();
			// unlock 을 하면 이제 thread가 작업해요
		}
		return _instance;
	}

	static void release_instance() {
		if (_instance) {
			delete _instance;
			_instance = nullptr;
		}
	}
};

요즘 대부분은 lock, unlock 이 아닌 동일한 기능을 하는 std::lock_guard 를 사용하고 있습니다.
-- 참조 : http://en.cppreference.com/w/cpp/thread/lock_guard

간단히 thread 2개를 생성해서 singletone 객체를 생성하는 코드를 구성해 보겠습니다.





#include <iostream>
#include <mutex>

#include <thread>

class singleton
{
	static singleton* _instance;
	static std::mutex _mutex;
	singleton() {};

public:
	singleton(const singleton& other) = delete;
	static singleton* get_instance()
	{
		std::lock_guard<std::mutex> lock(_mutex);
		if (_instance == nullptr)
		{
			//_mutex.lock();
			_instance = new singleton();
			//_mutex.unlock()
			std::cout << "한번만 실행됩니다." << std::endl;
		}
		return _instance;
	}

	static void release_instance() {
		if (_instance) {
			delete _instance;
			_instance = nullptr;
		}
	}
};
//http://en.cppreference.com/w/cpp/language/static 참조
std::mutex singleton::_mutex;
singleton* singleton::_instance = nullptr;


void make_instance_with_thread(singleton* ptr)
{
	ptr = singleton::get_instance();
}

int main()
{
	singleton* instance;
	std::thread t1(make_instance_with_thread, instance);
	std::thread t2(make_instance_with_thread, instance);
	
	t1.join(); t2.join();
	instance->release_instance();
	return 0;
}

iterator (c++)

기루광 — Mon, 24 Apr 2017 22:09:21 +0900

iterator : 컨테이너에 저장된 원소를 순회하고 접근하는 일반화된 방법을 제공합니다.

iterator 를 말할때 항상 빠지지 않는 내용이 container 입니다.

**반복자
임의의 컨테이너의 알고리즘을 몰라도 순회를 이어주는 매개 역할을 합니다.

즉, vector, linkedlist 유사한 컨테이너임에도 물리적 자료구조가 전혀 다른 container로 순회하는 방법이 아주 다릅니다. 이렇게 제 각각인 container 들에 대해 순회 방법을 일반화하기 위해 STL 에서 사용하는 개념이 바로 반복자 입니다.

custom container 를 구현한다고 했을 때, 가장 많이 사용하는 방법이 std::iterator를 상속받아 inner class로 구현하는 방식 입니다. 우선 custom container 를 구현하여 iteration 순회 및 c++11 의 range based for loop 가 동작하도록 구현해보겠습니다.





// custom container with inner iterator class
#include <iostream>
#include <algorithm>


template<class T>
class rkvector
{
	int _size = 0;
	T* _buffer = nullptr;

public:
	/*
	template<
		class Category,
		class T,
		class Distance = std::ptrdiff_t,(depressed c++17)
		class Pointer = T*,
		class Reference = T&
	> struct iterator;
	*/

	// inner iterator class
	class iterator : std::iterator<std::input_iterator_tag, T>
	{
		T* _ptr;
	public:
		explicit iterator(T* ptr) :_ptr(ptr) {}
		// ++ 연산자 경우 직접적인 값이 아니라 iterator 를 반환
		// * 연산자를 통해서만 직접적인 값을 반환

		iterator& operator++() { ++_ptr; return (*this); }
		iterator operator++(int) { iterator retval = *this; ++_ptr; return retval; }

		reference operator*() { return *_ptr; }
		bool operator==(iterator other) const { return _ptr == other._ptr; }
		bool operator!=(iterator other) const { return _ptr != other._ptr; }
	};


	// 생성자
	rkvector() {}
	rkvector(int size)
	{
		if (_buffer == nullptr)
		{
			std::cout << "dynamic allocate" << std::endl;
			_buffer = new T[size];

			// T()  <-어떤 의미 일까요?
			std::fill(_buffer, _buffer + size, T());
			_size = size;
		}
	}

	// 소멸자
	~rkvector()
	{
		if (_size > 1)
			delete _buffer;
		else
			delete[] _buffer;
	}


	int size() const
	{
		return _size;
	}

	T operator[](int index) const
	{
		return _buffer[index];
	}

	iterator begin()
	{
		return iterator(_buffer);
	}
	iterator end()
	{
		return iterator(_buffer + _size);
	}

	void fill(T&& val)
	{
		for (int i = 0; i < _size;++i)
			_buffer[i] = val;
	}
};

int main()
{
	rkvector<int> vec(5);
	vec.fill(20);
	
	for (rkvector<int>::iterator it = vec.begin(); it != vec.end(); ++it)
	{
		std::cout << *it << std::endl;
	}
	std::cout << "C++11 range based for loop" << std::endl;
	for (int element : vec)
	{
		std::cout << element << std::endl;
	}
	return 0;
}
// road

STL vector 의 iterator 가 위와 같이 구현이 가능합니다.

C++11 ragne based for loop 가 지원됨에 따라서 바로 for( : ) 문을 통해서도 순회가 가능하게 바뀌었습니다.

>> 출력 값

dynamic allocate

C++11 range based for loop

Design Patterns

기루광 — Sun, 23 Apr 2017 23:02:27 +0900

보통 디자인 패턴은 크게 보면 아래 3가지 그룹이 있습니다.

5월 한달간 아래 내용에 대해서 천천히 정리를 하도록 하겠습니다.

1. Creational Patterns ( 객체 생성에 관여하는 pattern)

1. Abstract Factory
2. Builder
3. Factory Method
4. Prototype
5. Singleton : http://roadcom.tistory.com/7

2. Structural Patterns ( class 관계 및 구조를 표현하는 pattern)

1. Adaptor
2. Bridge
3. Composite
4. Decorator
5. Facade
6. Flyweight
7. Proxy

3. Behavioral Patterns ( 어떤 행동에 집중하는 pattern)

1. Mediator
2. Memento
3. Interpreter
4. Iterator : http://roadcom.tistory.com/4
5. Chain of Responsibility
6. Command
7. State
8. Strategy : http://roadcom.tistory.com/15
9. Observer
10. Template Method
11. Visitor : http://roadcom.tistory.com/16