블로그 이미지
윤영식
Application Architecter, Full Stacker, KnowHow Dispenser and Bike Rider

Publication

Statistics Graph

Recent Comment

Weight 초기화 잘하기 강좌를 정리한다. 





Deep Network의 문제점


- sigmoid를 ReLU(렐루)로 변경

- weight(초기) 값을 잘 못 사용하고 있다. 


sigmoid를 사용할 때 layer가 깊어져도 cost가 전혀 줄어들지 않았다. 

- 주의: 0 값은 절대 주지 말아야 한다.







RBM (Restricted Boatman Machine)


Hinton교수가 2006년 논문(A Fast Learning Algorithm for Deep Belief Nets) 에서 초기값을 잘 구하는 RBM을 소개함.

- forward: x (입력)값을 통해 w, b를 구한다

- backward: 생성된 w, b를 거꾸로 계산한다.

=> forward, backward의 결과를 보고 Weigth을 조정한다. 즉, Weight값을 학습을 통해 적절한 Weight값을 구한다.

 



Deep Belief Network


이전과 다음 Layer마다 RBM을 이용해 Weigth을 구하여 Multi Layer를 구성하 것을 Deep Belief Network이라고 한다. 

- RBM통해 Weight값 얻는 Training을 Fine Tunning이라고 부른다.


RBM 보다 더 간단한 초기화가 나옴. 



Xavier Initialization (샤이버)


- fan_in/2를 하면 쉽게 더 좋은 weight값을 얻을 수 있다.


정확도(Accuracy) 비교  테이블


- 최기화 메소드 쓰기

- ReLU 쓰기

등의 2가지 문제가 해결되었다. 







참조


- 김성훈교수님의 Weight 초기화 잘 해보자 강좌

- 다른 강좌 정리 블로글

- ReLU 소개 



posted by peter yun 윤영식

TensorBoard 사용하기 강좌를 정리한다





TensorBoard 사용하기 


5개의 step 을 거친다. 

1) 어떤것을 로깅할 것인지 정한다

2) all summary

3) summary 기록할 파일 위치 지정

4) session.run 실행

5) 별도 터미널에서 tensorboard --logdir=<지정폴더> 수행




Scalar (스케일러)





Histogram 

다차원 텐서의 경우 사용함. 



Graph

흐름도를 보고 싶을 경우 사용함.

- name_scope 사용하여 Layer를 구분하여 보기 좋게 한다. (접혔다 폈다 할 수 있음)




remote에 있는 tensorboard 보기





Multi run 하기 

부모 폴더만을 지정하면 child folder를 자동으로 보여줌 







9 Layer Tensorboard 구성시 문제점 


Deep Network을 다음과 같이 구성하고 Learning을 시킨 것이 Deep Learning이다. 



name_scope로 구분하여 Tensorboard에 표현 (강좌)

deep network를 구성할 때 코드로만 보면 어려울 수 있다. 이것을 시각화하여 다음과 같이 표현한다. 




결과 : 서로의 연결과 가중치(Weight)를 쉽게 볼 수 있다. 



9 layer를 거친다고 해서 정확도가 높아지는 것은 아니다. 2,3 layer는 잘 학습이 되지만 3 layer넘어가면 학습도가 떨어진다. 

이유: 결과의 1보다 작은 소숫점의 값을 multiply할 수록 더 작은 소숫점 값이 되어 버려서 gradient값이 살라진게 된다. 





Network으로 표현하면 좌측으로 갈 수록 점점 정확도가 떨어짐. 2006년까지 겨울이 찾아옮.

- 힌튼교수가 해결: Sigmoid를 잘 못 쓴것 같다. 

- ReLU를 적용해 보자. 








ReLU (Rectified Linear Unit, 렐루)


힌트 교수의 잘 못한 부분중 4번째 




ReLU 사용


- z값이 커질수로 1보다 작다라는 sigmoid를 0보다 커질 수록 갈 때까지 커진다.

- 대신 0보다 작으면 무조건 0이 된다. 


Sigmoid 대신 relu를 사용한다. 수식으로 표현하면 하고 앞으로 neural network에서는 최종 Layer를 빼고 hidden부분은 sigmoid를 사용하지 않고 relu를 사용해야 한다. 




9 layer의 relu와 sigmoid 사용 예




Activation Function

sigmoid와 relu등을 activation function이라고 하는데 다른 것들도 있다.

- sigmoid

- ReLU

- Leaky ReLU: 0이하일 때 약간 값을 살려줌

- ELU: 0이하일 때 원하는 값으로 살려줌

- Maxout



비교하면 LeRU 계열의 정확도가 높다.






참조


- 김성훈교수님의 TensorBoard 사용 강좌

- 김성훈교수님의 Backpropagation (chain rule) 희석 강좌

posted by peter yun 윤영식

미분 정리하기 강좌를 정리한다. 





미분


아주 작은 값을 대입하여 순간변화율을 구하는 것이다. 변화율은 기울기로 표현할 수 있다. 미분은 Gradient Descent에서 필수적인 공식이다.



편미분 (Partial derivative)


내가 관심있는 값은 미분하고 나머지는 상수로 치환하여 계산한다. 



- 상수 함수 미분하면 = 0

- 2x 는 x + x 이고 x를 각각 미분하면 각각 1 + 1 = 2가 됨

- x + 3 은 1 + 0 이므로 1이다. 


Chain rule에서 x가 f에 영향을 미치는 값을 알고 싶을 경우 미분으로 표현한다. 

 





참조


- 김성훈교수님의 미분강좌

- 칸아카데미의 Chain rule 강좌를 참조하자

posted by peter yun 윤영식

XOR 문제 풀기 강좌를 정리한다. 





Neural Network (NN)


XOR 를 Linear한 선으로 구분을 지을 수 없었다. NN에서 어떻게 해결하는가? Y1, Y2 가 Y예측으로 수렴되어 계산하는 것을 풀어본다. 





matrix를 곱하고, sigmoid function인 S(..)을 태워서 값이 0, 1중 어디에 근접하는지 살핀다. 


나머지를 다 계산해 본다. 나머지까지 답이 맞으면 만들어 놓은 Network이 맞는 것이된다. 



위의 3개 Network을 통해 XOR결과가 제대로 나왔다. 하나의 Neural Network을 만들었다. 



Multinomiad Classification처럼 하나의 Vector로 만들 수 있다. W, B가 matrix화 된다.


위의 것을 수식으로 표현할 수 있다.


과제는 여기서 W1, b1을 어떻게 알 수 있을까? 이다. 다음 강좌에서 알아본다. 



Deep NN for XOR (강좌)


여러개의 Layer를 만들어 INPUT, OUTPUT을 조절한다. 

- 이전 layer의 OUTPUT은 다음 Layer의 INPUT이 된다. (소스)



Deep & wide (강좌)


처음 INPUT 이 2개이고, 마지막 OUTPUT 이 1개 이다. 

- 최초 INPUT Layer

- 마지막 OUTPUT Layer

- 중간 HIDDEN Layer



HIDDEN Layer는 개발자 마음대로 넣으면 된다. 예로 9개의 Layer를 만들 경우는 다음과 같다. 

- Deep Network을 만들고 이것을 학습시키면 Deep Learning이 된다






참조


- 김성훈교수님의 XOR 문제 풀기 강좌

- 김성훈교수님의 XOR 문제를 NN으로 풀기 강좌

posted by peter yun 윤영식

Tensorflow Manipulation 강좌를 정리한다.





Array


- rank, shape, axis을 array로 나타냄.

- [-1] array의 마지막 item

- t[2:5] index 3부터 5까지 items

- t[:2] 처음부터 index 2까지 

- t[3:] index 3에서 끝까지 


[1,2,3] rank(1), shape(3)

[[1,2],[3,4]] rank(2), shape(2,2)


axis=0 가장 바깥쪽, axis=-1 가장 안쪽을 표현하고 axis을 통해 shape을 이동한다. 







Matrix Manipulation


matmul


matrix 곱은 반드시 matmul을 사용한다. 

- tf.matmul((2,2) , (2,1)) => (2,1)




broadcasting


matrix끼리 shape이 다르더라도 matrix끼리 연산을 가능토록 shape을 자동으로 맞춰준다. 잘 알고 사용하면 좋지만 조심해라. 



reduce_mean 


(평균) 호출시 입력값들의 type에 주의한다.


axis를 0 이냐 1 이냐에 따라 다른다.

>>> import tensorflow as tf

>>> sess = tf.Session()

>>> sess.run(tf.global_variables_initializer())

>>> x = [[1.,2.],[3.,4.]]

>>> tf.reduce_mean(x).eval(session=sess)

2.5


>>> tf.reduce_mean(x, axis=1).eval(session=sess)

array([1.5, 3.5], dtype=float32)



reduce_sum 


axis=-1  제일 안쪽값을 합치고 이에 대한 평균을 낸다. 



argmax


큰값이 있는 위치 index를 구하는 것이다. 



reshape


주로 (...., z) 가장 안쪽에 있는 z 값은 그대로 가져가고, 앞의 것을 reshape한다.



reshape 하나의 형태 sqeeze는 펴주는 역할, expand_dims 차원을 더 추가할 경우 




One Hot 


가장 큰 값이 있는 곳을 1로 하고 나머지는 0으로 바꿈. One hot을 하면 dimension (rank)가 하나 더 생기므로 다시 reshape을 한다. 

마지막 3만 남기고 나머지는 차원 1로 만들어주는 것 



Casting


타입 바꿔주기 



Stack


쌓기를 만들어줌. 주어진 데이터들에서 axis와 stack을 이용해 새로운 matrix를 만듦



Ones and Zeros like


가지고 있는 shape과 똑같은 0 또는 1로 채워진 shape을 만들때 사용



Zip


복수의 tensor를 한방에 처리하기 





참조


- 김성훈교수님의 Tensorflow Manipulation 강좌

- reduce_sum reduce_mean 사용법

posted by peter yun 윤영식

딥러닝 개념 강좌를 정리한다.





History


X Input을 가중치 W로 곱한후 모두 합한 다음 bias(b)를 더하고 activation function을 통할 때 1 또는 0으로 나온다. 1이면 수행하고 0이면 수행하지 않는다. 



XOR 문제. Linear하게 선을 그어도 심플한 모델을 가지고도 값을 구하지 못함. AND, OR는 단순하지만





1969 민스키 교수의 저서에서 XOR 문제해결을 위해 MultiLayer로 만들면 해결되지만 여기서 중간의 W, b를 학습할 수 없다이야기 함. 이에 대해 대부분 설득당 함.  




1986년 힌튼(Hinton)이 Back Propagation 알고리즘을 통해 error를 만날때 다시 뒤로 보내서 W,b를 구하자




Convolutional Neural Networks (CNN)


라쿤(LeCun) 교수는 다른 방법으로 접근. 그림을 볼 때 일부만 활성화 되고 부분마다 하는 역할이 틀리고 이들이 합쳐져서 판단하게 된다. 


부분부분을 예측하고 각각을 합쳐서 최종 판단한다. 

예) 자율주행차, 알파고



Backpropagation Big Problem


1990년대 Layer가 많아서 뒤로 갈 수록 제대로 전달되지 않는다. neural network보다 SVM, RandomForest같은 다른 알고리즘이 더 잘 동작함을 알게됨. 

다시 금 침체기에 들어간다. 




CIFAR(캐나다) 단체


CIFAR 에서 일하면 불씨를 이어감. 2006, 2007년 두개의 논문이 나옴.

- layer마다 초기값을 잘 주면 실행 가능하다

- 신경망을 구축하면 복잡한 문제를 해결할 수 있다. 

이때 Neural Network을 Deep Learning이라고 바꿈.




Hinton의 Alex박사가 ImageNet (이미지학습) 의 오류가 26% -> 15%로 떨어짐. 2015년에는 3%의 에러로 떨어졌다. (using Convolutional Neural Network)

요즘) Deep API, 알파고, 유튜브의 번역글, 페이스북의 피드, 구글검색엔진의 결과, 넷플릭스의 추천시스템, 아마존의 상품 추천시스템



잘 안되었던 4가지 상황



뒤 강좌에서 4가지 문제에 대해 알아본다.



지금 해야하는 이유






참조


- 김성훈교수님의 딥러닝 개념 강좌

- 김성훈교수님의 딥러닝 XOR 강좌

posted by peter yun 윤영식

Training/Test Set  강좌를 정리한다.




Training and test set


훈련시킬 데이터와 테스트 데이터를 나누어서 예측을 검증해 보아야 한다. 



Training set로 모델을 만들고 Validation set으로 모의 시험을 한다. 이후 Testing set으로 모델을 최종 테스트한다. 


테스트 데이터는 모델 입장에서 한번도 보지 않는 데이터가 된다. 






Big data set


Training set이 많을 경우. 몇개의 그룹으로 짤라서 학습을 시킨다. 이것을 Online Learning이라 부른다.

- image: training set

- label: Y 결과값이 있는 test set



데이터 사이즈 부르기 


- 전체 데이터를 한번 학습 시킨 것 = epoch (에포크)

- 몇개씩 짤라서 학습 = batch size

- epoch/batch size = iteration size 




Training Set으로 모델 만들기 예제





Testing Set으로 테스트하기 


- sess.run 또는 accuracy.eval 동일하다






참조


- 김성훈교수님의 Training/Testing 강좌

- Github MNIST data 예제



posted by peter yun 윤영식

ML Tips 강좌를 정리한다.




Learning rate 정하기


경사를 따라 내려가는 정도를 Learning rate이라 한다. 학습rate을 잘 정하는 것이 중요하다. 

- learning rate을 큰값을 사용할 때 밖으로 튕겨 나갈 때(overshooting) 잘 못된 값이다.

  


- learning rate이 작은값이면 step이 작아서 멈춰버릴 수 있다. 

   


해결 주로 초기에 0.01 으로 시작하고 작게 또는 크게 적용해 본다.




Big Learning rate


5 스텝에서 값이 무한대로 가버린다.



Small Learning rate


198 스텝이 되어도 cost의 값이 작지 않다면 의심해 봐야 한다. 




Data (X) preprocessing


Weight이 여러개 일때 2차원으로 표시할 경우 경사면을 따라서 낮은 지점에 내려가는 것이 목적이다. 데이터간 큰 차이가 있을 때 노말라이즈(Normalize)를 수행한다. 

- 0에 수렴되게 하거나

- 특정 범위안에 놓이게 하거나

학습이 제대로 이루어지지 않고 있다면 데이터중에 차이가 큰값이 있을 수 있다. 이를 제거하기 위해 Normalize를 한다. 



Learning rate도 적절한데 결과에 NaN이 있거나 이상하다면 Normalize 안된 Input값을 의심해 본다. w1, w2의 그래프를 보면 길게 늘어져 있으면 None Normalize이다.



해결하는 방법: MixMaxScaler(xy)를 사용한다.


예제 일부 코드

import tensorflow as tf

import numpy as np

tf.set_random_seed(777)  # for reproducibility



def MinMaxScaler(data):

    numerator = data - np.min(data, 0)

    denominator = np.max(data, 0) - np.min(data, 0)

    # noise term prevents the zero division

    return numerator / (denominator + 1e-7)



xy = np.array([[828.659973, 833.450012, 908100, 828.349976, 831.659973],

               [823.02002, 828.070007, 1828100, 821.655029, 828.070007],

               [819.929993, 824.400024, 1438100, 818.97998, 824.159973],

               [816, 820.958984, 1008100, 815.48999, 819.23999],

               [819.359985, 823, 1188100, 818.469971, 818.97998],

               [819, 823, 1198100, 816, 820.450012],

               [811.700012, 815.25, 1098100, 809.780029, 813.669983],

               [809.51001, 816.659973, 1398100, 804.539978, 809.559998]])


# very important. It does not work without it.

xy = MinMaxScaler(xy)

print(xy)


x_data = xy[:, 0:-1]

y_data = xy[:, [-1]]






Overfitting


학습데이터가 실제에 잘 맞지 않을 경우. 

- model은 일반적으로 적용가능하다 (regularization: 일반화)

- model2는 Overfitting으로 주어진 데이터에 specification되어 있다. => 특정 데이터에 맞춰서 선이 구부러져 있을 때 



Cost function에 Regularization(일반화)를 해준다. 선이 구부러진다는 것은 값이 커지는 것이므로 이를  조절 한다. 

Cost function = 기존 cost function + (람다*합W2)


람다: regularization strength





참조


- 김성훈교수님의 ML Tips 강좌

- 김성훈교수님의 Tips 실습 강좌

posted by peter yun 윤영식

Multinomial Classification에 사용하는 Softmax Classification을 Tensorflow로 구현하는 강좌를 정리한다.




Softmax Function


0.7 + 0.2 + 0.1 확률(Probabilities)값을 더하면 1이 된다. 






Cost Function


Loss function 구현하고 minize cost로 GradientDescentOptimizer를 사용한다. 




Tensorflow 실습


One-Hot Encoding은 하나의 자리만 1을 갖는다. 예) y_data

import tensorflow as tf

tf.set_random_seed(777)  # for reproducibility


x_data = [[1, 2, 1, 1],

          [2, 1, 3, 2],

          [3, 1, 3, 4],

          [4, 1, 5, 5],

          [1, 7, 5, 5],

          [1, 2, 5, 6],

          [1, 6, 6, 6],

          [1, 7, 7, 7]]

y_data = [[0, 0, 1],

          [0, 0, 1],

          [0, 0, 1],

          [0, 1, 0],

          [0, 1, 0],

          [0, 1, 0],

          [1, 0, 0],

          [1, 0, 0]]


X = tf.placeholder("float", [None, 4])

Y = tf.placeholder("float", [None, 3])

nb_classes = 3  #클래스의 갯수


# Shape

# 4 = X값, nb_classes 출력값

W = tf.Variable(tf.random_normal([4, nb_classes]), name='weight')

b = tf.Variable(tf.random_normal([nb_classes]), name='bias')


# tf.nn.softmax computes softmax activations

# softmax = exp(logits) / reduce_sum(exp(logits), dim)

hypothesis = tf.nn.softmax(tf.matmul(X, W) + b)


# Cross entropy cost/loss

cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)


# Launch graph

with tf.Session() as sess:

    sess.run(tf.global_variables_initializer())


    #Hypothesis에 대해 학습하여 최적의 W,b를 구함

    for step in range(2001):

        sess.run(optimizer, feed_dict={X: x_data, Y: y_data})

        if step % 200 == 0:

            print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}))


    print('--------------')


    # Testing & One-hot encoding: 예측을 하게 한다. argmax에서 최강자를 골라준다.


    a = sess.run(hypothesis, feed_dict={X: [[1, 11, 7, 9]]})

    print(a, sess.run(tf.argmax(a, 1)))


    print('--------------')


    b = sess.run(hypothesis, feed_dict={X: [[1, 3, 4, 3]]})

    print(b, sess.run(tf.argmax(b, 1)))


    print('--------------')


    c = sess.run(hypothesis, feed_dict={X: [[1, 1, 0, 1]]})

    print(c, sess.run(tf.argmax(c, 1)))


    print('--------------')


    all = sess.run(hypothesis, feed_dict={X: [[1, 11, 7, 9], [1, 3, 4, 3], [1, 1, 0, 1]]})

    print(all, sess.run(tf.argmax(all, 1)))



==> 결과 1 0 2

[[1.3890432e-03 9.9860197e-01 9.0612402e-06]

 [9.3119204e-01 6.2902056e-02 5.9058843e-03]

 [1.2732767e-08 3.3411323e-04 9.9966586e-01]] [1 0 2]






Fancy Softmax Classifier


cross_entropy, reshape, one-shot encoding을 사용하여 좀 더 Fancy하게 Softmax Classifier를 만든다. 

- score(logit)을 구함 => softmax function을 거치면 확률값이 나옴. 식: hypothesis  tf.nn.softmax(tf.matmul(X,W))


- hypothesis를 Cross entropy cost/Loss 를 만듦. 1)번 수식을 2)번 수식처럼 단순화함. Logits을 사용함.



동물원 예제

- 6가지 종류의 동물이 있다. 이것을 one hot을 이용해 가설을 학습시킨다. 

- tf.one_hot(...)을 호출하면 한차원 더 생기고 이것을 원위치 시키려면 tf.reshape(...)을 호출한다. 


import tensorflow as tf

import numpy as np

tf.set_random_seed(777)  # for reproducibility


# Predicting animal type based on various features

xy = np.loadtxt('data-04-zoo.csv', delimiter=',', dtype=np.float32)

x_data = xy[:, 0:-1]

y_data = xy[:, [-1]]


print(x_data.shape, y_data.shape)


nb_classes = 7  # 0 ~ 6


X = tf.placeholder(tf.float32, [None, 16])

Y = tf.placeholder(tf.int32, [None, 1])  # 0 ~ 6

Y_one_hot = tf.one_hot(Y, nb_classes)  # one hot

print("one_hot", Y_one_hot)

Y_one_hot = tf.reshape(Y_one_hot, [-1, nb_classes])

print("reshape", Y_one_hot)


W = tf.Variable(tf.random_normal([16, nb_classes]), name='weight')

b = tf.Variable(tf.random_normal([nb_classes]), name='bias')


# tf.nn.softmax computes softmax activations

# softmax = exp(logits) / reduce_sum(exp(logits), dim)

logits = tf.matmul(X, W) + b

hypothesis = tf.nn.softmax(logits)


# Cross entropy cost/loss

cost_i = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y_one_hot)

cost = tf.reduce_mean(cost_i)

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)


# 정확도를 구한다. 

prediction = tf.argmax(hypothesis, 1)

correct_prediction = tf.equal(prediction, tf.argmax(Y_one_hot, 1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# Launch graph

with tf.Session() as sess:

    sess.run(tf.global_variables_initializer())


    # 학습을 수행한다

    for step in range(2000):

        sess.run(optimizer, feed_dict={X: x_data, Y: y_data})

        if step % 100 == 0:

            loss, acc = sess.run([cost, accuracy], feed_dict={X: x_data, Y: y_data})

            print("Step: {:5}\tLoss: {:.3f}\tAcc: {:.2%}".format(

                step, loss, acc))


    # Let's see if we can predict: 잘 예측되는지 확인한다. 

    pred = sess.run(prediction, feed_dict={X: x_data})

    # y_data: (N,1) = flatten => (N, ) matches pred.shape

    for p, y in zip(pred, y_data.flatten()):

        print("[{}] Prediction: {} True Y: {}".format(p == int(y), p, int(y)))




동물을 특징 짖는 여러 가지 X 값에 대한 결과 Y값을 가지고 있을 때, 즉 Multinomial Classification을 할 때 Fancy Softmax Classifier를 사용한다.






참조


김성훈교수님의 Softmax Classification을 Tensorflow로 구현하는 강좌

- 김성훈교수 강좌 정리한 글-1, 잘 정리한 글-2, 잘 정리한 글-3

- Github Softmax Classification 예제-1

posted by peter yun 윤영식

여러개의 Classification 강좌를 정리한다. 





Logistic Regression


Y hat 은 예측이다. 두가지를 구분하는 선을 찾아내기를 학습한다. 

즉, Multinomial 을 0 또는 1을 만들고 이들을 구분하는 선을 찾는 것이다.




세번의 독립된 binary classification을 구한다. 

- A 이거나 not 아니거나

- B 이거나 not 아니거나

- C 이거나 not 아니거나 

개별적인 것을 Matrix로 표현한다.




Softmax를 이용한 단순화하기 


전체 값을 합치면 1이 되는 함수 = Softmax classifier (강좌)


예측 모델



0.7, 0.2, 0.1은 확률값과 같고 이를 classification하면 다음과 같이 a가 1이되고 나머지는 0이 된다. 

여기서 "One-Hot Encoding"을 이용하여 1 또는 0의 예측을 구한다.




Cost function


예측과 실제값의 비용함수를 구하기 위해 "Cross-Entropy"를 사용한다. Cost function의 결과값이 작으면 예측이 맞는 것이다. 크면 예측이 맞지 않는 것이다.

- D: 차이 Distance


하나에 대한 것은 기존의 Logistic cost function과 cross entropy공식은 같다. 



여러 Training set을 넣을 때 거리의 합에 대한 평균을 구한다. Loss (Cost) function 을 최종적으로 얻을 수 있다. 





Gradient Descent 적용


Cost function을 미분하면서 기울기가 가장 작은 값의 W값을 찾는다. 






참조


- 김성훈교수님의 Multinomial Classification 강좌

- 김성훈교수님의 Multinomial Classification의 Cost Function 강좌

posted by peter yun 윤영식

Logistic Classification 강좌를 정리한다. 




Regression vs Classification


- Regression: 숫자를 예측

- Classification: 정해진 카테고리를 정하는 것: Pass(1) 또는 Fail(0) 으로 판단한다.

   ex) Spam Detection, Facebook feed, Credit Card Fraud Detection


Linear Regression에서 x값이 너무 커서 Output이 1보다 커지는 것을 방지하기 위해 H(x) 를 z로 놓고, g(z)의 결과가 0 ~ 1 사이에 수렴되는 것을 sigmoid(시그모이드) 함수라 하고, Logistic function 이라고도 한다. 



수식은 다음과 같다. 







New Cost function for Logistic Classification


기존 Linear Regression과 Sigmoid function을 적용했을 때의 모습

- 기울기가 평평해 지는 지점에서 멈춤. 그러나 sigmoid에서는 기존 cost function을 적용하면 울퉁 불퉁하므로 시작점에 따라서 종료점(최소) 구간이 틀려질 수 있다. 즉 training을 멈추게 된다. 


따라서 Hypethesis를 변경했기 때문에 Cost function도 변경한다. 

- y:1 일때 예측이 틀릴경우 즉 H(x) = 0이면 cost 는 무한대가 된다. 

- y:0 일때 H(x) =0 이면 cost는 0이되고, H(x) = 1 이면 cost는 무한대가 된다. 

즉 잘 못 예측되면 cost가 무한대로 커진다. 


위의 수식을 y=0일때와 y=1일때 합치면 경사타고 내려가기인 그릇모양이 된다. 


공식에 대한 구현 코드는 다음과 같다. 






Logistic classifier를 Tensorflow로 구현하기


Y데이터 값으로 0 또는 1을 가지면 binary classification이다. None은 n개를 의미한다. (예제)



수식을 tensorflow 코드로 구현한다. 

- placeholder를 만들고

- sigmoid (logistic) function 구현

- new cost function 구현

- GradientDescenOptimizer를 이용한 경사 내려가기 미분 구현


결과: 1=true, 0=false 




예제

import tensorflow as tf

import numpy as np

tf.set_random_seed(777)  # for reproducibility


xy = np.loadtxt('data-03-diabetes.csv', delimiter=',', dtype=np.float32)

x_data = xy[:, 0:-1]

y_data = xy[:, [-1]]


print(x_data.shape, y_data.shape)


# placeholders for a tensor that will be always fed.

X = tf.placeholder(tf.float32, shape=[None, 8])

Y = tf.placeholder(tf.float32, shape=[None, 1])


W = tf.Variable(tf.random_normal([8, 1]), name='weight')

b = tf.Variable(tf.random_normal([1]), name='bias')


# Hypothesis using sigmoid: tf.div(1., 1. + tf.exp(-tf.matmul(X, W)))

hypothesis = tf.sigmoid(tf.matmul(X, W) + b)


# cost/loss function

cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) *

                       tf.log(1 - hypothesis))


train = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost)


# Accuracy computation

# True if hypothesis>0.5 else False

predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)

accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))


# Launch graph

with tf.Session() as sess:

    # Initialize TensorFlow variables

    sess.run(tf.global_variables_initializer())


    for step in range(10001):

        cost_val, _ = sess.run([cost, train], feed_dict={X: x_data, Y: y_data})

        if step % 200 == 0:

            print(step, cost_val)


    # Accuracy report

    h, c, a = sess.run([hypothesis, predicted, accuracy],

                       feed_dict={X: x_data, Y: y_data})

    print("\nHypothesis: ", h, "\nCorrect (Y): ", c, "\nAccuracy: ", a)





참조


- 김성훈교수님의 Logistic Classification 함수 강좌

- Github Logistic regression classification 예제, 파일 읽기 예제

posted by peter yun 윤영식

Multi Variable Linear Regression 강좌를 정리한다. 





Linear Regression 기본 개념

- Hypothesis: H(x) = Wx + b   => Input값을 통해 가설을 세운다. W, b에 따라 선의 모양일 달라진다.

- Cost function: cost(W,b) = H(x) - y 실제값의 차에 대한 제곱에 평균   =>    결과값을 바탕으로 가설을 검증하고 가장 적은 값을 갖는 W, b를 구한다. (참조)

- Gradient descent algorithm: 미분의 기울기에 따른 아래로 수렴되는 알고리즘  => Cost function을 최소화 하기 위한 최적화 알고리즘을 사용한다. (참조)

   -> 그릇처럼 밑으로 수렴되는 Convex Fuction을 사용하여 오류를 제거한다.


기존은 하나의 Input variable만 사용했다면 여러개의 multi variable에 대한 예측



변수(Variable)이 여러개(Multi)일 때 Matrix를 이용한다. Matrix를 사용할 때는 X가 앞에 오고 W가 뒤에 온다. + b 가 없을 때 수식은 아래와 같다. 



(x1, x2, x3)를 하나의 Instance라고 부른다. Instance가 많을 경우 다음과 같은 수식을 사용한다. W는 동일하다. 

- X: [Instance, #x]

- W: [#w, #]

연산시 #x와 #w의 숫자는 같아야 한다. 계산 결과는 [instance, #] 이 된다. 




위의 5값은 instance의 갯수는 가변이므로 n으로 표현한다. 보통 Tensorflow에서 None으로 표현하면 n개를 말한다. 그리고 n Output의 경우일때는 다음과 같다.



이론과 실제 구현상 공식. 수학적 의미는 거의 같다.







Tensorflow 실습하기 


x1, x2, x3 instance가 있고, 결과 Y 하나가 나온다.


 Maxtrix를 이용해서 구현해 본다. (예제)


import tensorflow as tf

tf.set_random_seed(777)  # for reproducibility


x_data = [[73., 80., 75.],

          [93., 88., 93.],

          [89., 91., 90.],

          [96., 98., 100.],

          [73., 66., 70.]]

y_data = [[152.],

          [185.],

          [180.],

          [196.],

          [142.]]



# placeholders for a tensor that will be always fed.

X = tf.placeholder(tf.float32, shape=[None, 3])

Y = tf.placeholder(tf.float32, shape=[None, 1])


W = tf.Variable(tf.random_normal([3, 1]), name='weight')

b = tf.Variable(tf.random_normal([1]), name='bias')


# Hypothesis

hypothesis = tf.matmul(X, W) + b


# Simplified cost/loss function

cost = tf.reduce_mean(tf.square(hypothesis - Y))


# Minimize

optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-5)

train = optimizer.minimize(cost)


# Launch the graph in a session.

sess = tf.Session()

# Initializes global variables in the graph.

sess.run(tf.global_variables_initializer())


for step in range(2001):

    cost_val, hy_val, _ = sess.run([cost, hypothesis, train], feed_dict={X: x_data, Y: y_data})

    if step % 10 == 0:

        print(step, "Cost: ", cost_val, "\nPrediction:\n", hy_val)


==> 결과

... 


2000 cost:  7.4047155

prediction:

 [[154.63629]

 [182.36778]

 [181.60802]

 [197.86899]

 [137.86888]]






파일에서 읽어 실행하기 


Python 의 numpy를 이용하여 읽어오고 slicing한다. (예제)


import numpy as np


xy = np.loadtxt('data-01-test-score.csv', delimiter=',', dtype=np.float32)

x_data = xy[:, 0:-1] # slicing

y_data = xy[:, [-1]]


읽을 내용이 많을 경우 한번에 가져오지 않고 Queuing하여 처리하는 Queue Runners를 제공한다. (예제)

Step-1: 여러개의 파일을 읽어온다. 

Step-2: 파일에서 key, value을 가져온다. 

Step-3: 값을 decoding한다.



import tensorflow as tf

tf.set_random_seed(777)  # for reproducibility


filename_queue = tf.train.string_input_producer(['data-01-test-score.csv'], shuffle=False, name='filename_queue')


reader = tf.TextLineReader()

key, value = reader.read(filename_queue)


# Default values, in case of empty columns. Also specifies the type of the

# decoded result.

record_defaults = [[0.], [0.], [0.], [0.]]

xy = tf.decode_csv(value, record_defaults=record_defaults)


# collect batches of csv in

train_x_batch, train_y_batch = tf.train.batch([xy[0:-1], xy[-1:]], batch_size=10) #10 개씩 처리 


# placeholders for a tensor that will be always fed.

X = tf.placeholder(tf.float32, shape=[None, 3])

Y = tf.placeholder(tf.float32, shape=[None, 1])


W = tf.Variable(tf.random_normal([3, 1]), name='weight')

b = tf.Variable(tf.random_normal([1]), name='bias')


# Hypothesis

hypothesis = tf.matmul(X, W) + b


# Simplified cost/loss function

cost = tf.reduce_mean(tf.square(hypothesis - Y))


# Minimize

optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-5)

train = optimizer.minimize(cost)


# Launch the graph in a session.

sess = tf.Session()

# Initializes global variables in the graph.

sess.run(tf.global_variables_initializer())


# Start populating the filename queue.

coord = tf.train.Coordinator()

threads = tf.train.start_queue_runners(sess=sess, coord=coord)


for step in range(2001):

    x_batch, y_batch = sess.run([train_x_batch, train_y_batch])

    cost_val, hy_val, _ = sess.run(

        [cost, hypothesis, train], feed_dict={X: x_batch, Y: y_batch})

    if step % 10 == 0:

        print(step, "Cost: ", cost_val, "\nPrediction:\n", hy_val)


coord.request_stop()

coord.join(threads)


# Ask my score

print("Your score will be ",

      sess.run(hypothesis, feed_dict={X: [[100, 70, 101]]}))


print("Other scores will be ",

      sess.run(hypothesis, feed_dict={X: [[60, 70, 110], [90, 100, 80]]}))





참고


- 김성훈교수님의 Multi-Variable linear regression 강좌

- Github 예제 4-1

- Github 예제 4-2 using Matrix

- 선형 & 다중 회귀분석


posted by peter yun 윤영식

Tensorflow를 이용해 Minimized Cost를 구하는 Algorithm실습 강좌를 정리한다.





Matplotlib 을 이용한 차팅


Python을 통해 그래프를 그리기 위해 matplotlib을 가이드에따라 설치한다. 

$ python -mpip install -U matplotlib


다음으로 ~/.matplotlib 밑에 matplotlibrc  파일을 생성하고 다음 내역을 작성한다. (참조)

backend: TkAgg


다음 코드를 작성하고 실행한다. 

W = 1 이 최소화를 위한 값이라는 것을 알 수 있다.






"W := W - 미분값" 이해


- 미분값은 경사도를 의미하고 좌에서 우로 내려가면 - 값, 좌에서 우로 올라가면 + 값이다.

- 마이너스 값이 되면 W + 미분값이 되어 W가 큰값으로 옮겨가고, W - 미분값은 W가 작은 값으로 수렴한다. 

  + a 알파값: learning-rate 상수값

  + = 은 assign펑션을 이용해 descent를 update에 할당한다. 

  + update operation를 run하면 graph를 통해 일련의 동작이 일어난다.  


Graph를 실행하는 단계

- Session생성

- 글로벌 값 초기화

- session.run 으로 Node (operation)수행



직접 미분을 구현하지 않고 위처럼 GradientDescentOptimizer를 사용할 수 있다.  만일 gradient값을 수정하고 싶을 때는 compute_gradient(cost)로 얻은 값을 직접 수정하여 적용할 수 있다.

gvs = optimizer.compute_gradient(cost)

// gvs를 customizing한다. 

apply_gradients = optimizer.apply_gradients(gvs)


....

sess.run(apply_gradients)






참조


김성훈교수님의 Minimized Cost function 실습 강좌

- Lab-03-2-minimizing_cost_show_graph.py

posted by peter yun 윤영식

Cost를 Minimize하는 방법 강좌를 정리한다. 





가설(Hyperthesis) 단순화


b를 제거하고 cost(W)에 대해 구한다. 이때 최소화 되는 구간을 찾는다. 그래프상으로 Y축 cost(W)와 X축 W의 관계에서 cost(W) = 0  인 지점이 최소화 지점이다. 



경사를 따라 내려가는 알고리즘 = Gradient Descent Algorithm 을 사용한다.

- 경사도가 있는 곳을 따라 움직이면서 cost를 줄인다. 미분이 경사도를 구하는 공식임.

- 즉, 해당 점의 기울기를 구한다.


Gradient Descent Algorithm Formal





Convex function


Cost function을 3차원으로 그렸을 때, 내려가는 경사를 잘 못 잡으면 내려간 곳의 W, b값이 틀려 질 수 있다. 알고리즘이 잘 동작하지 않는 예


Convex function을 통해 그릇형태로 만들어 어디를 내려오던 원하는 지점으로 수렴할 수 있다. Cost function을 만든 후 검증할 때 Convex function이 된다면 Linear Regression의 cost function은 잘 된 것으로 판명된다. 







참조


- 김성훈교수님의 Minimize Cost 강좌

posted by peter yun 윤영식

Linear Regression의 Tensorflow 실습 강좌를 정리해 본다. 





Hypothesis & Cost function (예측과 비용 함수)



학습을 통해 cost function의 W와 b를 minimized하는게 목적이다. 

- step-1: Node라는 operation 단위를 만든다. 

- step-2: Session.run을 통해 operation한다. 

- step-3: 결과값을 산출한다. 



Tensorflow는 W, b를 Variable로 할당한다. Variable이란 tensorflow가 변경하는 값이다라는 의미이다. 


H(x) 가설 구하기


$ python3

>>> import tensorflow as tf

>>> x_train = [1,2,3]

>>> y_train = [1,2,3]

>>> W = tf.Variable(tf.random_normal([1]), name='weight')

>>> b = tf.Variable(tf.random_normal([1]), name='bias')

>>> hypothesis = x_train * W + b


cost(W,b) 구하기

- reduce_mean: 전체 평균

- square: 제곱

>>> cost = tf.reduce_mean(tf.square(hypothesis - y_train))



minimize Cost 구하기

- GradienDescent 를 사용해서 minimize한다.

>>> optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)

>>> train = optimizer.minimize(cost)





Graph 실행하기


Tensorflow의 Session을 만들고, 글로벌 변수값을 초기화 해준다. 

- 2000번을 돌리면서 20번만다 출력해 본다. 

- sess.run(train): 학습을 시킨다. 처음 Cost를 랜덤하게 가면서 학습할 수록 값이 작이진다. 

   sess.run(W): 1에 수렴하고

   sess.run(b): 작은 값이 수렴한다.

>>> sess = tf.Session()

>>> sess.run(tf.global_variables_initializer())

>>> for step in range(2001):

...     sess.run(train)

...     if step % 20 == 0:

...             print(step, sess.run(cost), sess.run(W), sess.run(b))

...

0 8.145951 [-0.13096063] [-0.43867812]

20 0.0741704 [0.87371004] [0.00051325]

40 0.0009571453 [0.9702482] [0.04034551]

   ... 생략 ...

1960 2.7972684e-08 [0.9998057] [0.00044152]

1980 2.5414716e-08 [0.99981487] [0.00042076]

2000 2.3086448e-08 [0.9998234] [0.00040107]


위의 train은 여러 Node가 연결된 graph가 된다. 






Placeholder로 수행하기


수행시 필요할 때 값을 동적으로 전달하여 train해 본다. 

- X, Y placeholder를 만든다. 

- feed_dict를 통해 값을 할당한다.

>>> X = tf.placeholder(tf.float32)

>>> Y = tf.placeholder(tf.float32)

>>> for step in range(2001):

...     cost_val, W_val, b_val, _ = sess.run([cost, W, b, train], feed_dict={X: [1,2,3], Y:[1,2,3]})

...     if step % 20 == 0:

...             print(step, cost_val, W_val, b_val)

...

0 2.3086448e-08 [0.9998238] [0.00040011]

20 2.0964555e-08 [0.99983215] [0.00038142]






참조


- 김성훈교수님의 Linear Regression의 Tensorflow 실습

- Github 실습 코드

posted by peter yun 윤영식

성김님의 Linear Regression강좌 개념을 정리해 본다. 





Regression


- 범위에 관한 문제를 다룬다. 예측을 위한 기본적인 범위(x)를 통해 결과(y)에 대한 학습을 수행한다.

- Linear Regression 가설

  + 예: 학생이 공부를 많이 할 수록 성적이 높아지고, 훈련을 많이할 수록 기록이 좋아진다.

  + 아래와 같은 선을 찾는 것이 Linear Regression의 목적이다. 



H(x): 우리가 세운 가설

Wx: x 값

W, b 에 따라 선의 모양이 달라진다. 


예) 파란선: H(x) = 1 * x + 0

     노란선: H(x) = 0.5 * x + 2





Cost function


Linear Regression의 가설 선과 실제 값사이의 거리가 가까우면 잘 맞은 것이고, 아니면 잘 맞지 않은 것 일 수 있다. 이를 계산하는 산술식을 Cost(Lost) function이라 한다. 


- 예측값 H(x) 와 실제값 y 를 뺀 후 제곱을 한다. 제곱을 하는 이유는

  + 음수를 양수로 만들고

  + 차이에 대한 패널티를 더 준다. 

  cost = (H(x) - y) 2



수식에 대한 일반화



최종 목표는 W, b에 대해 가장 작은 값을 학습을 통해 찾는 것이다. - Goal: Minimize cost



minimize cost(W, b)





참조


- 김성훈교수님의 Linear Regression


posted by peter yun 윤영식

인프런의 모두를 위한 딥러닝을 공부하기 위해 Tensorflow를 설치해 보았다. 





Python 설치


python은 3.6.6을 설치한다. 3.7를 설치하고 Tensorflow를 설치하니 오류가 있었다. 


- Python v3.6.6설치

- pip python package 매니져를 업데이트 한다. 

curl https://bootstrap.pypa.io/get-pip.py | python


- virtualenv를 통해 특정 폴더에 대해 python version을 적용한다. 맨뒤 옵션이 특정 폴더이다.

$ virtualenv --system-site-packages -p python3 /Users/prototyping/machine-learning

$ cd machine-learning 

$ source ./bin/activate

(machine-learning)

~/prototyping/machine-learning

$




Tensorflow 설치


pip3를 이용해서 설치하는 방법이 실패하여 직접 download url을 입력한다. 

$ pip3 install --upgrade tensorflow (실패하면 아래 직접 URL 지정한다)

$ pip3 install --upgrade https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.8.0-py3-none-any.whl



이제 시작해 보자...



참조


- Mac에서 virtualenv설치하기

posted by peter yun 윤영식
2015.03.07 21:19 AI Deep Learning

NMF(non-negative matrix factorization) 기법을 소개한다. 이 기법은 데이터내에 독립된 특성을 찾는데 사용한다. 많은 데이터 세트 내의 항목들은 미리 알기 어려운 다른 특성들과의 조합으로 생성되고 이러한 특성을 찾아 본다. 






이전 분류 방식

  

  - 베이지안 분류기 (Classification)

  - 의사결정트리

  - 지지벡터머신(SVM)

  - 군집 (Clustering)




비음수 행렬 인수분해 (NMF)


  - 행렬 준비 

    + 특성 행렬(feature matrix) : 가로줄에 각각의 특성을 가졌고 세로줄에 단어, 값들은 단어 특성의 중요도

     


    + 가중치 행렬(weights matrix) : 가로줄 타이틀, 세로줄 특성

      


    + 행렬 만들기 = 특성 행렬 * 가중치 행렬


  - 비음수 행렬 인수분해라 불리는 이유는 음수가 아닌 특성과 가중치를 리턴하기 때문이다. 모든 특성은 양수 값을 가져야 함을 의미한다.

  - 단어 출현 횟수와 같은 명사류 데이터뿐만 아니라 주식시장 데이터와 같은 숫자 데이터 문제에도 잘 어울린다.

  - 진행 : 행렬 준비 -> NMF 실행 -> 결과 출력    

     * 특성을 나누는 행렬을 만들고 필요없는 특성을 제거하면서 원하는 차원을 줄여서 원하는 것을 종합적인 결과를 출력함




<참조> 

 

 - 얼굴 인식

 - PCA, NMF



<참조>

- 파이썬 가상환경 만들기

posted by peter yun 윤영식
2015.02.28 11:56 AI Deep Learning

선형 분류기 개념과 지지벡터머신(SVM, support-vector machines)에 대해 알아본다. 데이트 매칭에 데이터를 기본으로 알아봄. 



데이터 세트 


  - 데이터 분할에서 의사결정트리는 세로, 가로 직선으로 고지식함

  - 산포도(scatter plot chart)를 통해 도움받음 

 



기본 선형 분류


  - 산포도에서 각 범주(class) 내 모든 데이터들의 평균을 찾고 그 범주의 중앙을 나타내는 점을 만듦 (그림. 9-4)

  - 일치분류를 위해 백터의 각도를 계산해서 작으면 일치, 크면 불일치 (그림. 9-6)

  - 백터내적(dot-product) : 벡터와 벡터의 방향/크기 비교 






분류 데이터의 특성


  - 데이터 정규화 (Data Normalization)

  - 숫자로 변형 -> 예/아니오(1/-1), 관심/비관심(0/1) : 사람 쌍을 다룰 때 유용 

  - 공통 관심의 수, 모든 관심을 포용할 새로운 변수를 만듦

  - 거리 데이터 구함

  - 각 변수에 대한 축적(scale)을 조정함 : 최대/최소값 




커널 기법 이해

  

  - 커널 트릭 : 차원을 높이지 않고 차원을 올리는 효과를 거둠. 

  - 펑션을 통해 원하는 값을 구함 : 방사 펑션 (RBF: radial basis function)




지지 벡터 머신 (SVM)


  - 각 범주에서 가능한 멀리 떨어진 선을 찾아 해결하려고 시도한다. 비선형을 극복 (non-linear)

  - 먼저 범주를 나눈다 이때 커널 트릭을 사용해서 구하고 이것이 차원이 된다. 각 차원 즉 범주의 사이의 초평면(hyperplane)을 만든다. 

  - 해당 초평면에 근접한 것들이 매칭하는 것이다.  (그림. 9-10)





<참조> 


  - 내적 공간

  - 서포트 벡터 머신(한글), 서포트 벡터 머신 공식(영어)

  - 초평면

  - LIBSVM 라이브러리 

  - 정규화

posted by peter yun 윤영식
2015.02.21 13:23 AI Deep Learning

가격 결정을 위한 모델링은 이질적인 속성을 기반을 둔 숫자 데이터를 예측하는데 최적의 알고리즘이다.




kNN


  - K-nearnest neighbors : k는 마지막 결과를 얻기 위해 평균을 낼 물품의 개수를 말한다. 데이터가 완벽하다면 k=1을 사용한다. 

  - 인접개수의 평균을 낼 때 너무 작거나 크면 안되고 적정개수를 찾아야 한다. 




물품 가중치


  - 거리에 따라 가중치를 둔다. 물품들이 비슷할 수록 그들 간의 거리가 더 가까워진다. 

  - 물품들을 군집화하기 위한 방법 - 적정한 인접 개수를 구하는 것이 필요하다. 

  - 역함수(inverse function), 빼기 함수(substraction function), 가우스 함수(gaussian function)

  - 가중 kNN (Weighted kNN) : 가우시안을 구하고 평균을 구한다 




교차검증


  - 데이터를 학습 세트와 테스트 세트로 나누는 기법들을 총칭한다. (cross validation set) : 표본값을 잘 뽑는 방법

  - training set -> test set 




이질 변수


  - 가격 결정에 너무 큰 영향을 미치는 이질적 요소

  - 변수의 단위가 틀릴때 스케일(Scale)을 조정하여 대입한다. 




실습 


  - $ pip install virtualenvwrapper

 - $ source /usr/local/bin/virtualenvwrapper.sh

 - mkvirtualenv env1

 - vi requirements.txt

// requirements.txt 내역 

beautifulsoup4==4.3.2

html5lib==0.999

lxml==3.4.2

numpy==1.9.1

pandas==0.15.2

python-dateutil==2.4.0

pytz==2014.10

six==1.9.0

wsgiref==0.1.2


  - pip install ipython  (module 없을 경우 계속 pip install <moduleName>)

  - ipython notebook 을 통해서 실습 시작

  - chapter7의 treepredict 데이터 생성 : data.txt

Referrer,Location,Read FAQ,Pages viewed,Service chosen

Slashdot,USA,Yes,18,None

Google,France,Yes,23,Premium

Digg,USA,Yes,24,Basic

Kiwitobes,France,Yes,23,Basic

Google,UK,No,21,Premium

(direct),New Zealand,No,12,None

(direct),UK,No,21,Basic

Google,USA,No,24,Premium

Slashdot,France,Yes,19,None

Digg,USA,No,18,None

Google,UK,No,18,None

Kiwitobes,UK,No,19,None

Digg,New Zealand,Yes,12,Basic

Google,UK,Yes,18,Basic

Kiwitobes,France,Yes,19,Basic


  - treepredict.py 작성 : pandas 통해서 데이터 만듦

import pandas as pd 


def main():

  data = pd.read_csv("./data.txt", sep=",")

  print data

  values = data.values

  print values


if __name__ == '__main__':

  main()


  - pandas로 하면 데이터 유형이 틀려지므로 그냥 책에 있는 내용 copy&paste

  - 실행 내역을 html로 출력

$ ipython nbconvert treepredict.ipynb

[NbConvertApp] Using existing profile dir: u'/Users/nulpulum/.ipython/profile_default'

[NbConvertApp] Converting notebook treepredict.ipynb to html

[NbConvertApp] Support files will be in treepredict_files/

[NbConvertApp] Loaded template full.tpl

[NbConvertApp] Writing 202262 bytes to treepredict.html

(env1)




<참조> 


  - https://virtualenvwrapper.readthedocs.org/en/latest/ : python 가상 환경 

  - https://pypi.python.org/pypi/virtualenv

  - iPython notebook 사용하기 

posted by peter yun 윤영식
prev 1 2 3 next