분류 전체보기 (336)

반응형

/**

날짜 : 2017/1/30

작성자 : 3개월

텐서플로우 상수, 변수, 플레이스 홀더

**/


어떠한 프로그래밍 언어를 배울 때 해당 언어의 자료구조에 대한 이해는 매우 중요하다. 자료를 대상으로 어플리케이션을 만들거나 예측 모델을 만들기 때문이다. 텐서플로우에서의 자료구조는 크게 상수(Constant), 변수(Variable), 심볼릭변수(placeholder)로 나뉜다. 세 종류는 특성이 모두 다르므로 이를 제대로 아는 것이 중요하다. 아래는 텐서플로우에서 이 자료 구조들을 어떻게 생성하고 다루는지 실습한 것이다. 


1. 상수


기본적인 상수 생성 방법 


""" 텐서플로우 상수
    references : 텐서플로우 첫걸음 &
    https://tensorflowkorea.gitbooks.io/tensorflow-kr/content/g3doc/api_docs/python/constant_op.html
"""
import tensorflow as tf

points = [[1,2,3],[4,5,6]] # 2차원 배열
print(points)

vectors = tf.constant(points) # 텐서플로우 상수 생성

print(vectors) # Tensor("Const_9:0", shape=(2, 3), dtype=int32)
print(vectors.get_shape()) # 2x3

expanded_vectors = tf.expand_dims(vectors, 0) # 2-D 텐서를 3-D 텐서로 차원 확장

print(expanded_vectors) # Tensor("ExpandDims_6:0", shape=(1, 2, 3), dtype=int32)
print(expanded_vectors.get_shape()) # 1x2x3

# value 를 출력하려면 아래와 같이 세션 생성 후 run 해야함
sess = tf.Session()
print(sess.run(vectors)) # [[1 2 3]
                         # [4 5 6]]
print(sess.run(expanded_vectors)) #[[[1 2 3]
                                  # [4 5 6]]]


상수를 생성하는 여러가지 방법


""" 상수를 생성하는 여러가지 방법 """
zeros = tf.zeros_like([4,3,3], dtype=tf.int32, name='zeros')
print(sess.run(zeros)) # [0,0,0] (입력으로 받은 텐서와 같은 shape의 텐서인데 0으로 초기화된 것)

# zeros와 zeros_like의 차이점 잘 비교. 일반적으로 zeros를 많이 쓸거 같음.
zeros2 = tf.zeros([3,4,5], dtype=tf.int32, name='zeros2')
print(sess.run(zeros2)) # 0으로 초기화된 3x4x5 텐서가 만들어짐

ones = tf.ones([2,2,3], dtype=tf.float32)
print(sess.run(ones)) # 1로 초기화된 2x2x3 텐서가 만들어짐

fill = tf.fill([2,3], 9) # 9로 초기화된 2x3 텐서
print(sess.run(fill))

contant = tf.constant([2,3,4]) # 주어진 텐서를 그대로 텐서플로우 변수로 전환
print(sess.run(contant)) # [2 3 4]

tensor = tf.constant(-1.0, shape=[2, 3])# tf.fill([2,3], -1.0) 과 같음
print(sess.run(tensor))


* 난수 상수 생성 -> weight 초기화 할 때 자주 이용


""" 난수 상수 생성 """
# 정규분포 난수
norm = tf.random_normal([2, 3], mean=-1, stddev=4)
print(sess.run(norm))

# 주어진 값들을 shuffle
c = tf.constant([[1, 2], [3, 4], [5, 6]])
shuff = tf.random_shuffle(c)
print(sess.run(shuff))

# 균등분포 난수
unif = tf.random_uniform([2,3], minval=0, maxval=3)
print(sess.run(unif))


시퀀스 상수 생성


""" 시퀀스 """
lin = tf.linspace(10.0, 12.0, 3, name="linspace")
print(sess.run(lin))

# start부터 시작하여 limit까지 (limit는 포함하지 않음) delta의 증가량만큼 확장하며 정수 리스트를 생성합니다.
ran = tf.range(start=3, limit=7, delta=1) 
print(sess.run(ran)) # [3 4 5 6]

# start의 default는 0
ran2 = tf.range(8)
print(sess.run(ran2)) # [0 1 2 3 4 5 6 7]


난수 생성시 Seed의 활용

  • seed를 활용함으로써 매 실행마다 같은 결과를 내도록 할 수 있다.


""" 난수 생성시 seed의 활용 """
a = tf.random_uniform([1], seed=1) # seed를 주고 random한 값을 생성하면 매 session마다 값이 같음
b = tf.random_normal([1])

# Repeatedly running this block with the same graph will generate the same
# sequence of values for 'a', but different sequences of values for 'b'.
print("Session 1")
with tf.Session() as sess1:
  print(sess1.run(a))  # generates 'A1'
  print(sess1.run(a))  # generates 'A2'
  print(sess1.run(b))  # generates 'B1'
  print(sess1.run(b))  # generates 'B2'

print("Session 2")
with tf.Session() as sess2:
  print(sess2.run(a))  # generates 'A1'
  print(sess2.run(a))  # generates 'A2'
  print(sess2.run(b))  # generates 'B3'
  print(sess2.run(b))  # generates 'B4'
    
# tf.set_random_seed를 통해 모든 random value generation function들이 매번 같은 값을 반환함    
tf.set_random_seed(1234)
a = tf.random_uniform([1])
b = tf.random_normal([1])

# Repeatedly running this block with the same graph will generate different
# sequences of 'a' and 'b'.
print("Session 1")
with tf.Session() as sess1:
  print(sess1.run(a))  # generates 'A1'
  print(sess1.run(a))  # generates 'A2'
  print(sess1.run(b))  # generates 'B1'
  print(sess1.run(b))  # generates 'B2'

print("Session 2")
with tf.Session() as sess2:
  print(sess2.run(a))  # generates 'A1'
  print(sess2.run(a))  # generates 'A2'
  print(sess2.run(b))  # generates 'B1'
  print(sess2.run(b))  # generates 'B2'


2. 변수


변수 생성


""" 텐서플로우 변수 
    reference : https://tensorflowkorea.gitbooks.io/tensorflow-kr/content/g3doc/how_tos/variables/
"""
# 두 변수를 생성.
weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),
                      name="weights")
biases = tf.Variable(tf.zeros([200]), name="biases")

# 변수는 반드시 initialization 해야한다.


변수 초기화

  • 변수는 초기화하지 않으면 사용할 수 없다. 반드시 initialization 하여야 한다.


# 변수 초기화

# 두 변수를 생성
weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),
                      name="weights")
biases = tf.Variable(tf.zeros([200]), name="biases")

# 변수 초기화 오퍼레이션을 초기화
init_op = tf.global_variables_initializer()

# 나중에 모델을 실행할때
with tf.Session() as sess:
    sess.run(init_op) # initialization 연산 실행
    print(sess.run(weights))
    print(sess.run(biases))


다른 변수값을 참조하여 변수 초기화


# 다른 변수값을 참조하여 초기화 하기

# 랜덤 값으로 새로운 변수 초기화
weights = tf.Variable(tf.random_normal([784, 200], stddev=0.35),
                      name="weights")
# weights와 같은 값으로 다른 변수 초기화
w2 = tf.Variable(weights.initialized_value(), name="w2")
# weights의 2배 값으로 다른 변수 초기화
w_twice = tf.Variable(weights.initialized_value() * 2.0, name="w_twice")

# 변수 초기화 오퍼레이션을 초기화
init_op = tf.global_variables_initializer()

with tf.Session() as sess : 
    sess.run(init_op)
    print(sess.run(w2))
    print(sess.run(w_twice))



3. 플레이스홀더

실행시에 데이터를 제공하는 방법으로 실제 딥러닝 모델 구축시 많이 쓰인다. sess.run 에서 feed_dict에 dictionary 형식으로 값을 넣어주면 되고 이를 feeding이라 한다.


""" 텐서플로우 심볼릭 변수(플레이스홀더)
"""
a = tf.placeholder("float")
b = tf.placeholder("float")

y = tf.mul(a,b)

sess = tf.Session()

print(sess.run(y, feed_dict={a : 3, b: 5})) # 15.0


반응형
반응형

/**

날짜 : 2017.01.30

밑바닥부터 시작하는 딥러닝(한빛미디어) 참고

Softmax 구현 및 성질

*/


Softmax 함수는 3-class 이상의 classification을 목적으로 하는 딥러닝 모델의 출력층에서 일반적으로 쓰이는 활성화 함수(activation function)이다. Softmax 함수는 아래와 같이 나타낼 수 있다.




이를 Latex 표기법으로 나타내면 아래와 같다. (Latex는 라텍스라고 읽으면 안되고 레이택으로 읽는다..)


\begin{align}

y_k = {exp(a_k)}/{\sum_{i=1}^{n}(exp(a_i))}

\end{align}


(위 코드를 Jupyter notebook에서 markdown으로 선택하여 입력 후 run을 누르면 위와 같은 수식이 출력되는 것을 확인할 수 있다. Jupyter notebook에서는 Latex 코드를 수식으로 변환하는 기능을 지원한다.)


""" Softmax 구현 """
import numpy as np

def softmax(a) :
    exp_a = np.exp(a)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    
    return y

a = np.array([0.3, 2.9, 4.0])

print softmax(a) # softmax 결과값 출력
print sum(softmax(a)) # softmax 결과값들의 합은 1이 된다.


Softmax 수식을 그대로 파이썬 코드로 옮기면 위와 같다. 결과가 잘 출력되는 것을 확인할 수 있다. 하지만 Softmax는 수식 안에 e의 지수를 포함하고 있는데, 지수함수는 지수가 커질 수록 매우 큰 폭으로 증가하기 때문에 overflow가 발생하기 쉽다. 아래 코드를 보면 overflow가 발생하는 예와 이를 어떻게 해결하는지를 볼 수 있다.


""" Softmax는 Overflow에 취약하다.
    수식에 e^x 들어가기 때문에 Overflow 범위를 넘어설 수 있다. 
    이를 해결하기 위해서는 Softmax의 성질을 이용한다.
"""
def new_softmax(a) : 
    c = np.max(a) # 최댓값
    exp_a = np.exp(a-c) # 각각의 원소에 최댓값을 뺀 값에 exp를 취한다. (이를 통해 overflow 방지)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y
    
a = np.array([1010, 1000, 990]) 
print softmax(a) # overflow
print new_softmax(a) # 정상적으로 출력

# 또한 softmax와 new_softmax 의 결과값을 같다.
test = np.array([1,3,6])
print 'softmax', softmax(test) # [ 0.00637746  0.04712342  0.94649912]
print 'new_softmax', new_softmax(test) # [ 0.00637746  0.04712342  0.94649912]


Softmax를 구현할 때 overflow 가 자주 발생하는 문제를 해결하기 위해 위와 같은 새로운 softmax 함수인 new_softmax를 정의한다. 이는 원소에 어떠한 수를 더하여 exp를 취하더라도 결과 값이 같다는 softmax의 성질을 이용한 것인데, 


위의 등식에서 C를 '원소들의 최댓값의 음수'로 한 것이다. 예를 들어 a = [1010,1000,990] a+c = [0,-10,-20] 이 된다. 이 때, a와 a+c의 softmax 결과값은 같다.



반응형
반응형

/**

날짜 : 2017.01.25

밑바닥부터 시작하는 딥러닝(한빛미디어) 참고

Numpy 기초, 간단한 신경망 구현

*/



numpy 패키지는 데이터 과학, 딥러닝 분야에서 쓰이는 매우 중요한 파이썬 패키지이다. numpy는 거의 표준이라고 불릴만큼 대부분의 사람들이 애용하는 패키지이다. numpy가 쓰이는 가장 큰 목적 중에 하나는 배열, 행렬, 벡터, 텐서와 같은 '다차원 배열'의 구현이다. 많은 사람들이 다차원 배열을 구현할 때 numpy를 이용한다. numpy에서는 이를 ndarray라고 부른다. 또 파이썬의 기본 자료 구조에는 array가 없기 때문에, 꼭 딥러닝이 아니더라도 numpy array는 파이썬에서 1차원 배열을 구현할 때도 쓰인다.


numpy의 기초 문법을 정리하고 이를 이용하여 인풋 2개, 아웃풋 2개, 히든 레이어가 2개(각각 노드수가 3, 2인)인 간단한 신경망을 구현해 보았다.


import numpy as np

A = np.array([1,2,3,4])

print(A)

# 차원출력
np.ndim(A)

# 배열 형상 출력. 튜플로 반환된다.

print A.shape
# (4L,)

print A.shape[0]
# 4


  • 위와 같은 문법을 통해 numpy array를 만들 수 있고, shape, dimension 등을 확인할 수 있다.


""" 2차원 배열 """
B = np.array([[1,2], [3,4], [5,6]])
print(B)

np.ndim(B)

B.shape


  • 2중 대괄호를 쓰면 2차원 배열을 만들 수 있다.


""" 3차원 배열 이상 """
# 2x3x4 배열을 만들고 0으로 초기화
C = np.zeros((2, 3, 4))

print 'C', C

# 아래와 같이 자유롭게 만들 수 있음
D = np.array([[[ 1., 2., 3., 4.],
        [ 0.,  0.,  2.,  0.],
        [ 4.,  0.,  3.,  0.]],
       [[ 1.,  4.,  0.,  6.],
        [ 0.,  0.,  5.,  0.],
        [ 0.,  0.,  0.,  5.]]])

print 'D', D

# 2x2x3x4 4차원 배열
E = np.zeros((2,2,3,4))
print 'E', E


  • 위와 같이 3차원 배열, 4차원 배열 등의 고차원 배열을 만들 수 있다.


""" 내적 """
A = np.array([[1,2], [3,4]])
A.shape

B = np.array([[5,6], [7,8]])
B.shape

np.dot(A,B)

#array([[19, 22],
#       [43, 50]])


  • np.dot 명령어를 통해 두 행렬의 내적(dot product)을 구할 수 있다. 신경망에서 이전층에서 다음층으로 forward 되는 것을 구현할 때 입력과 출력을 행렬의 내적으로 표현할 수 있다.


""" 간단한 신경망 구현 
    입력층에서 1층으로 가는 신호 
    첫 번째 히든 레이어의 노드 수는 3개
"""

def sigmoid(num) : 
    return 1/(1+np.exp(-num))

X = np.array([1.0,0.5]) # 입력이 2개 (x1, x2)
W1 = np.array([[0.1,0.3,0.5],[0.2,0.4,0.6]]) # 입력에 대응하는 weights 
B1 = np.array([0.1,0.2,0.3]) # bias

print X.shape # 1x2
print W1.shape # 2x3
print B1.shape # 1x3

A1 = np.dot(X,W1) + B1
Z1 = sigmoid(A1) # 첫 번째 레이어의 최종 아웃풋

print A1
print Z1


입력층에서 첫 번째 히든 레이어(노드 3개짜리)로 forward하는 것을 구현한 것이다. 입력과 weights, bias는 임의로 정한 것이다. 입력은 x1, x2 이고 각각 1.0,  0.5 이다. weights는 총 6개이다. (이는 input layer의 노드 수 2와 첫 번째 히든레이어의 노드수 3을 곱한 것이다.) bias는 길이 3의 array인데 이를 더해주어 XW에 더하여 XW+B를 만든다. Bias가 왜 필요한지 그리고 신경망에 대한 기본적인 이해는 http://hunkim.github.io/ml/ 홍콩 과기대 김성훈 교수님의 강의를 참조하면 좋다.


""" 1층에서 2층으로 가는 신호 구현
"""
W2 = np.array([[0.1,0.4],[0.2,0.5],[0.3,0.6]])
B2 = np.array([0.1,0.2])

print Z1.shape # 1x3 첫 번째 레이어의 아웃풋이 인풋이 된다.
print W2.shape # 3x2
print B2.shape # 1x2

A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid(A2)


 첫 번째 히든레이어에서 두 번째 히든레이어로 forward하는 것의 구현이다. 첫번째 히든 레이어의 아웃풋 Z1이 인풋이 되었고 위와 같은 방식으로 Z1*W2+B2를 하면 두 번째 히든 레이어의 output을 구할 수 있다.


""" 2층에서 출력층으로 가는 신호 구현
"""

# 출력층의 활성화 함수로 항등함수를 쓴다. 
# 회귀의 경우 출력층의 활성화 함수로 일반적으로 항등항수를  쓴다.
# 2-class classification에서는 sigmoid
# 3-class 이상의 classification에서는 softmax를 쓴다.
def identity_function(x) :
    return x

W3 = np.array([[0.1,0.3],[0.2,0.4]])
B3 = np.array([0.1,0.2])

print Z2.shape # 1x2
print W3.shape # 2x2
print B3.shape # 1x2

A3 = np.dot(Z2, W3) + B3
Y = identity_function(A3)

print Y # 최종 아웃풋 출력 


두 번째 히든 레이어에서 출력층으로 forward 하는 것의 구현이다. 출력층의 activation function은 identity function을 사용하였는데, 이는 '풀고자 하는 문제의 성질' 과 관련이 있다. 회귀에서는 항등함수를, 2클래스 분류에서는 시그모이드를, 다중 클래스 분류에는 소프트 맥스 함수를 사용하는 것이 일반적이다.

반응형
반응형

/**

날짜 : 2017.01.25

밑바닥부터 시작하는 딥러닝(한빛미디어) 참고

activation function 정리

*/


1. Step Function


import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
""" 일반적인 step_function """
def step_function(x) : 
    if x > 0 :
        return 1
    else : 
        return 0

""" numpy의 트릭을 사용한 step function 구현 """
def step_function_np(x) : 
    y = x > 0
    # boolean을 int로 변환하면 True = 1, False = 0이 된다.
    # numpy 배열의 type을 변경할 때 .astype을 쓴다.
    return y.astype(np.int)


첫 번째 step_function의 경우 numpy array를 입력으로 받아들일 수 없다. 반면 step_function_np 함수는 numpy array를 입력으로 받아들일 수 있다. 아래의 경우 y = x > 0 에서 boolean 형식의 numpy array가 반환되는 점을 트릭으로 활용하여 이를 step_function 구현해 활용한 것이다.


실제로 파이썬에서 deep learning 알고리즘을 구현할 때는 일반적으로 numpy array를 입력으로 받아 numpy array를 출력으로 내보내는 함수를 작성하는 것이 편하므로 step_function_np와 같이 구현하는 것이 더 바람직하다.


x = np.arange(-5.0, 5.0, 0.1) # -5.0부터 5.0까지 0.1 간격의 numpy array 생성
y = step_function_np(x)

plt.plot(x,y)
plt.ylim(-0.1,1.1)
plt.show()



2. Sigmoid function


def sigmoid(x) :
    return 1 / (1+np.exp(-x))

x = np.array([-1.0, 1.0, 2.0])

# numpy broadcast 기능으로 인해 정상수행
sigmoid(x)


  • numpy broadcast 기능으로 인해 numpy array에 어떠한 연산을 하면 각각의 element에 연산이 적용된 numpy array가 반환된다.


x = np.arange(-5.0,5.0,0.1)
plt.plot(x, sigmoid(x))
plt.ylim(-0.1,1.1)
plt.show()


  • np.arange는 -5.0 부터 5.0까지 0.1 간격으로 numpy array를 생성해준다.



3. ReLU


def relu(x) : 
    return np.maximum(0, x)


x = np.arange(-5.0,5.0,0.1)
plt.plot(x, relu(x))
plt.show()





반응형
반응형

XECore 설치

https://www.xpressengine.com/download


Autoset 설치

http://autoset.net/xe/download_autoset_9_0_0


  • Autoset9/public_html 폴더에 xe 폴더를 붙여넣고 서버 시작
  • http://127.0.0.1/xe 접속 아래와 같은 화면이 나옴




이후부터 XPress Engine Manual 보고 따라하면 됨


참고 

Autoset 에서 Mysql 이용법



결과

http://127.0.0.1/xe 접속시 아래와 같은 샘플 어플리케이션을 볼 수 있음


반응형
반응형

/**

날짜 : 2017.1.22

작성자 : 3개월

제목 : MNIST 데이터로 CNN Training 해보기

*/



1. 패키지 로드 & 데이터 읽기


""" Simple Convolutional Neural Network for MNIST """
import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import Flatten
from keras.layers.convolutional import Convolution2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend as K
K.set_image_dim_ordering('th')
import cPickle, gzip, numpy

# Load the dataset
f = gzip.open('mnist.pkl.gz', 'rb')
train_set, valid_set, test_set = cPickle.load(f)
f.close()


필요한 패키지들을 불러오고 데이터들을 불러옵니다.

mnist.pkl.gz는 

https://github.com/mnielsen/neural-networks-and-deep-learning/blob/master/data/mnist.pkl.gz 

에서 다운로드 후 코드와 같은 폴더에 붙여 넣으시면 됩니다.


# train_set 은 튜플로 두 개의 ndsarray를 원소로 가지고 있음
print train_set
print type(train_set)
print len(train_set)

# 튜플을 이렇게 둘로 나눌 수 있음
X_train, y_train = train_set
X_test, y_test = test_set

print type(X_train)
print len(X_train)
print len(y_train)
print X_train
print y_train


이제 MNIST 데이터를 읽어들였고, training set과 test set이 준비 완료되었습니다. 하지만 cnn에서는 x vector의 형태를 알맞게 고치는 preprocessing 작업이 필요합니다.  


2. 데이터 preprocessing


""" In Keras, the layers used for two-dimensional convolutions expect pixel values with the dimensions [pixels][width][height]. """
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype('float32') X_test = X_test.reshape(X_test.shape[0], 1, 28, 28).astype('float32') # normalize inputs from 0-255 to 0-1 X_train = X_train / 255 X_test = X_test / 255 # one hot encode outputs y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) num_classes = y_test.shape[1] # fix random seed for reproducibility seed = 7 numpy.random.seed(seed)


위와 같이 numpy의 reshape함수를 이용하여 X vector를 [pixels][width][height] 형태로 바꿔줍니다. (이 때 X_train.shape = (50000L, 784L) 라서 X_train.shape[0] = 50000 입니다.)


  • keras에서 cnn을 구현할 때 [pixels][width][height] 형태로 input을 받습니다. (Theano Backend의 경우)

piexels는 흑백이므로 1을 입력하고 MNIST데이터는 28x28 손글씨 이미지이므로 width = 28, height = 28을 입력합니다. 만약 컬러라면 3을 넣어야합니다. 이제 모든 training 데이터와 test 데이터의 준비는 끝났습니다.


3. CNN 모델 


def cnn_model():
    # create model
    model = Sequential()
    model.add(Convolution2D(32, 5, 5, border_mode='valid', input_shape=(1, 28, 28), activation='relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.2))
    model.add(Flatten())
    model.add(Dense(127, activation='relu'))
    model.add(Dense(num_classes, activation='softmax'))
    # Compile model
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    return model


CNN 모델을 구축하여보겠습니다. 

위 모델은 Convolution Layer-ReLU-Pooling Layer-(Dropout)-Fully Connected Network로 이어지는 구조이며 기본적인 CNN의 구조입니다.


  • Convolution2D(32,5,5...)에서 32는 feature map의 갯수라 할 수 있고 5,5는 5x5 필터 사이즈를 의미합니다. 
  • border_mode는 zero-padding에 관한 세팅입니다. valid는 valid convolution을 의미하여 padding을 주지 않습니다. 만약 same인 경우 same convolution이며 zero-padding을 넣어 convolution 결과의 사이즈과 인풋과 같게 합니다.


4. Training & Test


# build the model
model = cnn_model()
# Fit the model
model.fit(X_train, y_train, validation_data=(X_test, y_test), nb_epoch=10, batch_size=200, verbose=2)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" % (100-scores[1]*100))



이제 CNN을 트레이닝해보겠습니다. validation set은 test set으로 대체하였고, epoch=10, batch_size=200으로 하였습니다. verbose는 로깅에 관한 세팅으로 개념을 이해할 때는 무시하셔도 좋습니다.





error는 validation error을 기준으로 하며 마지막 epoch의 validation error에서 (1-0.9370)*100을 하여 6.3%가 됩니다. 앞서 MLP로 training하였을때는 7% 대에 error를 보였지만 CNN을 통해서 error rate를 낮출 수 있었습니다.






반응형
반응형

/**

Keras Mnist Learning Using Multi Layer Perceptron

작성자 : 3개월

날짜 : 2017.1.20

코드하이라이터 : http://markup.su/highlighter/

*/


1. 데이터 읽기


import cPickle, gzip, numpy

# Load the dataset
f = gzip.open('mnist.pkl.gz', 'rb')
train_set, valid_set, test_set = cPickle.load(f)
f.close()


mnist.pkl.gz는

https://github.com/mnielsen/neural-networks-and-deep-learning/blob/master/data/mnist.pkl.gz 

에서 다운로드 후 코드와 같은 폴더에 붙여 넣으시면 됩니다.


cPickle.load(f)를 하면 train_set, valid_set, test_set이 알아서 나뉘어집니다.


# train_set 은 튜플로 두 개의 ndsarray를 원소로 가지고 있음
print train_set
print type(train_set)
print len(train_set)

# 튜플을 이렇게 둘로 나눌 수 있음
X_train, y_train = train_set
X_test, y_test = test_set

print type(X_train)
print len(X_train)
print len(y_train)
print X_train
print y_train


train_set을 위와 같이 X_train, y_train 으로 나눌 수 있습니다.

train_set은 2개의 원소(X, Y)를 갖고 있는 '튜플' 인데 튜플인 경우 저러한 문법이 가능합니다.


2. Multi Layer Perceptron 구현


CNN을 활용하기 전에 Multi Layer Perceptrons을 이용하여 데이터셋을 러닝해봅니다. universal approximation theorem에 의해 사실 이 MLP로도 이미지 classification을 포함한 이 세상에 존재하는 모든 문제를 해결할 수 있습니다. (다만 데이터가 부족할뿐) 


# multi-layer perceptron
import numpy
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.utils import np_utils


패키지를 임포트합니다.


seed = 7
numpy.random.seed(seed)


계속 실행하더라도 동일한 결과를 갖기 위해 numpy random seed를 설정해줍니다.


print type(X_train)
print type(y_train)


타입은 두 개 모두 ndarray입니다. X_train은 784*50000 2차원 배열, y_train은 길이가 50000인 1차원 배열입니다. 784는 MNIST 데이터가 28*28 =784 픽셀 흑백 손글씨 이미지이기 때문에 나온 숫자이고 이를 일렬로 쭉 늘어놓은 것입니다. 또한 50000은 데이터의 갯수입니다. 


# normalize inputs from 0-255 to 0-1
X_train = X_train / 255
X_test = X_test / 255


흑백 이미지 데이터는 픽셀 하나당 0-255까지의 숫자값을 가지므로 이를 255로 나누면 0-1 사이로 normalize됩니다.


# one hot encode outputs
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)

# y_test 의 column을 클래스의 갯수 지정 : 10개
num_classes = y_test.shape[1]
num_pixels = X_train.shape[1]


위와 같이 y 값들을 one hot encoding 합니다.

또 아래 MLP 모델을 구축할 때 쓰는 변수들 num_classes, num_pixels를 정의합니다.


# define baseline model
def baseline_model():
    # create model
    model = Sequential()
    model.add(Dense(num_pixels, input_dim=num_pixels, init='normal', activation='relu'))
    model.add(Dense(num_classes, init='normal', activation='softmax'))
    # Compile model
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    return model

def good_model():
    # create model
    model = Sequential()
    model.add(Dense(400, input_dim=num_pixels, init='normal', activation='relu'))
    model.add(Dense(100, init='normal', activation='relu'))
    model.add(Dense(num_classes, init='normal', activation='softmax'))
    # Compile model
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
    return model


위와 같이 두 개의 MLP를 만들었습니다.

baseline_model은 히든 레이어가 한 개인 네트워크이고, good_model은 히든 레이어가 두 개인 네트워크입니다.


  • keras의 경우 input layer는 생략하며 첫 번째 히든 레이어에 "input_dim=인풋 레이어의 노드 수"를 지정하는 식으로 네트워크를 구성합니다.
  • 히든 레이어가 많고, 한 레이어당 노드 수가 적을 수록 overfitting이 적어져 generalization이 잘된다고 알려져있습니다.

데이터를 통해 위 두 개의 네트워크를 훈련하고 테스트해보겠습니다.



3. Training & Test


히든 레이어 한 개짜리 MLP


# build the model
model = baseline_model()
# Fit the model
model.fit(X_train, y_train, validation_data=(X_test, y_test), nb_epoch=10, batch_size=200, verbose=2)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" % (100-scores[1]*100))


첫 번째 모델인 baseline_model을 train하고 test하는 코드입니다. 

validation set은 test set으로 대체하였습니다. 

실행시 아래와 같이 10번 epoch을 돌면서, training accuracy, loss와 validation accuracy, loss를 출력합니다. 



error는 validation accuracy를 기준으로하며 (1-0.9232)*100 = 7.68% 입니다.



히든 레이어 두 개짜리 MLP (더 Deep 한 모델)


# build the model
model2 = good_model()
# Fit the model
model2.fit(X_train, y_train, validation_data=(X_test, y_test), nb_epoch=10, batch_size=200, verbose=2)
# Final evaluation of the model
scores = model2.evaluate(X_test, y_test, verbose=0)
print("Baseline Error: %.2f%%" % (100-scores[1]*100))


두 번째 모델인 good_model을 기준으로 training 과 test를 합니다.




위와 같이 Error가 7.54%로 첫 번째 네트워크보다 accuracy가 다소 높은 것을 알 수 있습니다.


4. 결론


MLP로 MNIST 데이터를 training하고 test 해보았습니다. MNIST와 같이 이미지 사이즈가 작고 흑백인 이미지에는 MLP도 꽤 괜찮은 accuracy를 내준다는 것을 알 수 있습니다. 하지만 이미지의 사이즈가 커지고 class의 갯수가 많아질 수록 CNN(Convolutional Neural Network)과 같은 이미지 처리에 최적화된 네트워크를 쓰는 것이 훨씬 효율적일 것입니다. 또한 training할 때 layer와 갯수와 layer당 node수를 적절히 선택하는 것이 중요하며 보통 이 사이즈는 try & error로 구하는 경우가 많습니다. 물론 네트워크를 구성하고 training 해본 경험이 많다면 어느정도의 layer와 node수를 선택해야하는지에 대해 어느정도 직감을 가질 수 있습니다.





반응형
반응형

PACS와 DICOM


DICOM은 의료 영상의 국제 표준이고,

PACS는 '의학영상정보시스템'의 약자로 의료영상을 관리하는 프로그램입니다.  

여러 회사에서 다양한 방식으로 PACS를 구현하고 있고, 병원에서는 자기 분야에 맞는 PACS를 가져다 씁니다.


쉽게말해 DICOM은 파일 형식이고, PACS는 DICOM 파일을 보는 소프트웨어입니다. 

일반인도 DICOM 뷰어를 다운로드받아 DICOM 형식의 파일을 읽어볼 수 있습니다.


참고


PACS

http://infinitt-healthcare.blog.me/220902279599


DICOM

http://infinitt-healthcare.blog.me/220902279599



반응형

'Domains > Bioinformatics' 카테고리의 다른 글

platypus 설치  (0) 2017.08.07
samtools 설치시 에러 해결  (0) 2017.07.16
윈도우 우분투에 GATK 설치하기  (0) 2017.06.24
non-coding RNA는 어떻게 만들어지나?  (0) 2017.05.28
tRNA란 무엇인가?  (0) 2017.05.25
반응형

데이터 분석 대회 Kaggle에 나왔던 타이타닉 데이터로 로지스틱 회귀분석 연습을 해보았습니다. 데이터를 통해 성별, 나이, 객실 등급이 승객의 생존에 어떤 영향을 끼쳤는지 분석해 볼 수 있습니다.



알아보고 싶은 것은 "성별(Sex), 나이(Age), 객실등급(Pclass), 요금?(Fare) 가 생존에 어떻게 어느정도의 영향을 미쳤는가?" 입니다.


=============================================================================================

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# 2015. 8. 5 
 
import pandas as pd
import statsmodels.api as sm
import pylab as pl
import numpy as np
import test2
 
df = pd.read_csv("c:/train2.csv"# read file
 
print df.head()
 
cols_to_keep = ['Survived''Age''Fare'# 분류할 수 없는 컬럼들
 
# 분류할 수 있는 컬럼들은 더미 컬럼를 만든다.
dummy_Pclass = pd.get_dummies(df['Pclass'], prefix='Pclass')
dummy_Sex = pd.get_dummies(df['Sex'], prefix='Sex')
 
# 더미를 데이터에 이어 붙인다.
data = df[cols_to_keep].join(dummy_Pclass.ix[:,'Pclass_2':]) # Pclass_2 부터 이어 붙임. 이래야 분석에 편리함
data = data.join(dummy_Sex.ix[:,'Sex_male':]) # Sex_male만 이어 붙임
 
data['intercept'= 1.0
 
# 지금까지의 데이터 확인
print data.head()
 
 
# 출력창에 다음과 같이 뜸
#   Survived  Age     Fare  Pclass_2  Pclass_3  Sex_male  intercept
#0         0   22   7.2500         0         1         1          1
#1         1   38  71.2833         0         0         0          1
#2         1   26   7.9250         0         1         0          1
#3         1   35  53.1000         0         0         0          1
#4         0   35   8.0500         0         1         1          1
 
 
# logistic regression
train_cols = data.columns[1:] # train_cols는 설명 변수
logit = sm.Logit(data['Survived'], data[train_cols]) # Survived는 목적 변수
 
# fit the model
result = logit.fit() 
 
print result.summary() # 분석결과 출력
 
#==============================================================================
#                 coef    std err          z      P>|z|      [95.0% Conf. Int.]
#------------------------------------------------------------------------------
#Age           -0.0330      0.007     -4.457      0.000        -0.048    -0.019
#Fare           0.0007      0.002      0.340      0.734        -0.003     0.005
#Pclass_2      -1.0809      0.286     -3.778      0.000        -1.642    -0.520
#Pclass_3      -2.2794      0.280     -8.142      0.000        -2.828    -1.731
#Sex_male      -2.6049      0.188    -13.881      0.000        -2.973    -2.237
#intercept      3.4772      0.418      8.318      0.000         2.658     4.297
#==============================================================================
 
# odds ratios only
print np.exp(result.params) # 오즈 비(Odds Ratio) 출력
 
#Age           0.967515
#Fare          1.000714
#Pclass_2      0.339281
#Pclass_3      0.102351
#Sex_male      0.073911
#intercept    32.367967
 
data["predict"= result.predict(data[train_cols])
print data.head()
 
# 최종결과 (predict가 생존확률)
#   Survived  Age     Fare  Pclass_2  Pclass_3  Sex_male  intercept   predict
#0         0   22   7.2500         0         1         1          1  0.106363
#1         1   38  71.2833         0         0         0          1  0.906625
#2         1   26   7.9250         0         1         0          1  0.585365
#3         1   35  53.1000         0         0         0          1  0.913663
#4         0   35   8.0500         0         1         1          1  0.071945
cs




분석 결과 정리


coef(편회귀계수)의 부호만을 봤을 때, 나이가 많을 수록, 여자보다는 남자일 수록, 1등급보다는 2등급, 3등급일 수록, 요금이 적을 수록 생존확률이 낮아졌다. 또한 coef의 절대값으로 미루어보면 성별이 생존여부에 가장 큰 영향을 미치는 것을 알 수 있었다.



용어


Odds Ratio 

Odds Ratio란 Odds의 비율이다. Odds란 성공/실패와 같이 상호 배타적이며 전체를 이루고 있는 것들의 비율을 의미한다. 예를 들어 남자 승객의 경우 577명중 109명이 생존했다. 이 경우 Odds = P(생존)/P(사망) = (109/577)/(468/577) = 0.19/0.81 = 0.23

여자 승객의 경우 314명중 233명이 생존했다. 이 경우 Odds = P(생존)/P(사망) = (233/314)/(81/314) = 2.87

따라서 Odds Ratio = 0.23/2.87 = 약 0.08


반응형
반응형

http://blog.yhathq.com/posts/logistic-regression-and-python.html


알고 싶은 것 : GPA, GRE, 모교 우선순위(prestige) 가 대학원 입학 여부에 어떻게 영향을 미치는가?

---------------------------------------------------------------------------------------------------------------------------

위의 블로그의 내용을 요약한 글입니다. 정리한 글은 위의 블로그에 더욱 자세하게 설명되어 있습니다.
환경 : python 2.7, eclipse pydev

1. 데이터 읽기
 
1
2
3
4
5
6
7
8
9
10
11
12
import pandas as pd
import statsmodels.api as sm
import pylab as pl
import numpy as np
 
 
print df.head()
 
df.columns = ["admit""gre""gpa""prestige"# df의 column 이름 바꾸기
print df.columns
 
cs


2. 데이터 요약하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
print df.describe() # 빈도수, 평균, 분산, 최솟값, 최댓값, 1/4분위수, 중위값, 1/4분위수를 나타냄
 
#             admit         gre         gpa   prestige
# count  400.000000  400.000000  400.000000  400.00000
# mean     0.317500  587.700000    3.389900    2.48500
# std      0.466087  115.516536    0.380567    0.94446
# min      0.000000  220.000000    2.260000    1.00000
# 25%      0.000000  520.000000    3.130000    2.00000
# 50%      0.000000  580.000000    3.395000    2.00000
# 75%      1.000000  660.000000    3.670000    3.00000
# max      1.000000  800.000000    4.000000    4.00000
 
print df.std() # 분산 출력
 
# admit      0.466087
# gre      115.516536
# gpa        0.380567
# prestige   0.944460
 
print pd.crosstab(df['admit'], df['prestige'], rownames=['admit'])
 
# prestige   1   2   3   4
# admit                   
# 0         28  97  93  55
# 1         33  54  28  12
 
df.hist()
pl.show() # pl.show()를 해야 화면에 띄워준다! 결과는 아래와 같다. 모든 컬럼에 대해 히스토그램을 그림
cs

3. 더미변수로 고치기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
dummy_ranks = pd.get_dummies(df['prestige'], prefix='prestige')
print dummy_ranks.head()
 
#    prestige_1  prestige_2  prestige_3  prestige_4
# 0           0           0           1           0
# 1           0           0           1           0
# 2           1           0           0           0
# 3           0           0           0           1
# 4           0           0           0           1
 
cols_to_keep = ['admit''gre''gpa']
data = df[cols_to_keep].join(dummy_ranks.ix[:, 'prestige_2':])
print data.head()
#    admit  gre   gpa  prestige_2  prestige_3  prestige_4
# 0      0  380  3.61           0           1           0
# 1      1  660  3.67           0           1           0
# 2      1  800  4.00           0           0           0
# 3      1  640  3.19           0           0           1
# 4      0  520  2.93           0           0           1
 
data['intercept'= 1.0
 
cs

4. 회귀분석을 시행한다.

1
2
3
4
5
6
train_cols = data.columns[1:]
logit = sm.Logit(data['admit'], data[train_cols])
result = logit.fit()
print result.summary()
 
 
cs
              Logit Regression Results                           
          ==============================================================================
          Dep. Variable:                  admit   No. Observations:                  400
          Model:                          Logit   Df Residuals:                      394
          Method:                           MLE   Df Model:                            5
          Date:                Sun, 03 Mar 2013   Pseudo R-squ.:                 0.08292
          Time:                        12:34:59   Log-Likelihood:                -229.26
          converged:                       True   LL-Null:                       -249.99
                                                  LLR p-value:                 7.578e-08
          ==============================================================================
                           coef    std err          z      P>|z|      [95.0% Conf. Int.]
          ------------------------------------------------------------------------------
          gre            0.0023      0.001      2.070      0.038         0.000     0.004
          gpa            0.8040      0.332      2.423      0.015         0.154     1.454
          prestige_2    -0.6754      0.316     -2.134      0.033        -1.296    -0.055
          prestige_3    -1.3402      0.345     -3.881      0.000        -2.017    -0.663
          prestige_4    -1.5515      0.418     -3.713      0.000        -2.370    -0.733
          intercept     -3.9900      1.140     -3.500      0.000        -6.224    -1.756
          ==============================================================================

coef에 주목한다. gre:0.0023 gpa :0.840, prestige_2 : -0.6754 등등...
coef(편회귀계수)의 값이 양수이면 그 컬럼의 값이 커질수록 목적변수가 TRUE일 확률 즉, admit=1일 확률이 높아진다.
반대로 coef의 값이 음수이면 그 컬럼의 값이 커질수록 목적변수가 FALSE일 확률 즉, admin=0일 확률이 높아진다.

즉 GRE나 GPA가 커질수록 대학원에 입학할 확률은 커지고 prestige_2, prestige_3이 커질수록 대학원에 입학할 확률은 작아진다. 
이러한 경향은 pretige가 낮아질수록 심해진다.


5. odds ratio

1
2
3
4
5
6
7
print np.exp(result.params)
# gre 1.002267
# gpa 2.234545
# prestige_2 0.508931
# prestige_3 0.261792
# prestige_4 0.211938
# intercept 0.018500
cs

 


반응형