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

Publication

06-25 02:49

Category

Recent Comment

2018. 7. 11. 15:08 AI Deep Learning/NN by Sung Kim

Class, tf.layers, Ensemble 강좌를 정리한다.




Python Class로 관리하기 


파이썬의 클래스로 만들어 사용하자. 복잡한 layer를 만들 때 사용하자.



예제

class Model:


    def __init__(self, sess, name):

        self.sess = sess

        self.name = name

        self._build_net()


    def _build_net(self):

        with tf.variable_scope(self.name):

            # dropout (keep_prob) rate  0.7~0.5 on training, but should be 1

            # for testing

            self.keep_prob = tf.placeholder(tf.float32)


            # input place holders

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

            # img 28x28x1 (black/white)

            X_img = tf.reshape(self.X, [-1, 28, 28, 1])

            self.Y = tf.placeholder(tf.float32, [None, 10])


            # L1 ImgIn shape=(?, 28, 28, 1)

            W1 = tf.Variable(tf.random_normal([3, 3, 1, 32], stddev=0.01))

            #    Conv     -> (?, 28, 28, 32)

            #    Pool     -> (?, 14, 14, 32)

            L1 = tf.nn.conv2d(X_img, W1, strides=[1, 1, 1, 1], padding='SAME')

            L1 = tf.nn.relu(L1)

            L1 = tf.nn.max_pool(L1, ksize=[1, 2, 2, 1],

                                strides=[1, 2, 2, 1], padding='SAME')

            L1 = tf.nn.dropout(L1, keep_prob=self.keep_prob)

            '''

            Tensor("Conv2D:0", shape=(?, 28, 28, 32), dtype=float32)

            Tensor("Relu:0", shape=(?, 28, 28, 32), dtype=float32)

            Tensor("MaxPool:0", shape=(?, 14, 14, 32), dtype=float32)

            Tensor("dropout/mul:0", shape=(?, 14, 14, 32), dtype=float32)

            '''


            # L2 ImgIn shape=(?, 14, 14, 32)

            W2 = tf.Variable(tf.random_normal([3, 3, 32, 64], stddev=0.01))

            #    Conv      ->(?, 14, 14, 64)

            #    Pool      ->(?, 7, 7, 64)

            L2 = tf.nn.conv2d(L1, W2, strides=[1, 1, 1, 1], padding='SAME')

            L2 = tf.nn.relu(L2)

            L2 = tf.nn.max_pool(L2, ksize=[1, 2, 2, 1],

                                strides=[1, 2, 2, 1], padding='SAME')

            L2 = tf.nn.dropout(L2, keep_prob=self.keep_prob)

            '''

            Tensor("Conv2D_1:0", shape=(?, 14, 14, 64), dtype=float32)

            Tensor("Relu_1:0", shape=(?, 14, 14, 64), dtype=float32)

            Tensor("MaxPool_1:0", shape=(?, 7, 7, 64), dtype=float32)

            Tensor("dropout_1/mul:0", shape=(?, 7, 7, 64), dtype=float32)

            '''


            # L3 ImgIn shape=(?, 7, 7, 64)

            W3 = tf.Variable(tf.random_normal([3, 3, 64, 128], stddev=0.01))

            #    Conv      ->(?, 7, 7, 128)

            #    Pool      ->(?, 4, 4, 128)

            #    Reshape   ->(?, 4 * 4 * 128) # Flatten them for FC

            L3 = tf.nn.conv2d(L2, W3, strides=[1, 1, 1, 1], padding='SAME')

            L3 = tf.nn.relu(L3)

            L3 = tf.nn.max_pool(L3, ksize=[1, 2, 2, 1], strides=[

                                1, 2, 2, 1], padding='SAME')

            L3 = tf.nn.dropout(L3, keep_prob=self.keep_prob)


            L3_flat = tf.reshape(L3, [-1, 128 * 4 * 4])

            '''

            Tensor("Conv2D_2:0", shape=(?, 7, 7, 128), dtype=float32)

            Tensor("Relu_2:0", shape=(?, 7, 7, 128), dtype=float32)

            Tensor("MaxPool_2:0", shape=(?, 4, 4, 128), dtype=float32)

            Tensor("dropout_2/mul:0", shape=(?, 4, 4, 128), dtype=float32)

            Tensor("Reshape_1:0", shape=(?, 2048), dtype=float32)

            '''


            # L4 FC 4x4x128 inputs -> 625 outputs

            W4 = tf.get_variable("W4", shape=[128 * 4 * 4, 625],

                                 initializer=tf.contrib.layers.xavier_initializer())

            b4 = tf.Variable(tf.random_normal([625]))

            L4 = tf.nn.relu(tf.matmul(L3_flat, W4) + b4)

            L4 = tf.nn.dropout(L4, keep_prob=self.keep_prob)

            '''

            Tensor("Relu_3:0", shape=(?, 625), dtype=float32)

            Tensor("dropout_3/mul:0", shape=(?, 625), dtype=float32)

            '''


            # L5 Final FC 625 inputs -> 10 outputs

            W5 = tf.get_variable("W5", shape=[625, 10],

                                 initializer=tf.contrib.layers.xavier_initializer())

            b5 = tf.Variable(tf.random_normal([10]))

            self.logits = tf.matmul(L4, W5) + b5

            '''

            Tensor("add_1:0", shape=(?, 10), dtype=float32)

            '''


        # define cost/loss & optimizer

        self.cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(

            logits=self.logits, labels=self.Y))

        self.optimizer = tf.train.AdamOptimizer(

            learning_rate=learning_rate).minimize(self.cost)


        correct_prediction = tf.equal(

            tf.argmax(self.logits, 1), tf.argmax(self.Y, 1))

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


    def predict(self, x_test, keep_prop=1.0):

        return self.sess.run(self.logits, feed_dict={self.X: x_test, self.keep_prob: keep_prop})


    def get_accuracy(self, x_test, y_test, keep_prop=1.0):

        return self.sess.run(self.accuracy, feed_dict={self.X: x_test, self.Y: y_test, self.keep_prob: keep_prop})


    def train(self, x_data, y_data, keep_prop=0.7):

        return self.sess.run([self.cost, self.optimizer], feed_dict={

            self.X: x_data, self.Y: y_data, self.keep_prob: keep_prop})








Layer API


conv2d: convolution layer

dense: fully conntected

예제








Ensemble 사용하기 


여러개를 조합해서 조화롭게 만든다. 여러개의 독립된 Model을 training시키고, 각 예측을 조합하여 최종 결과를 만든다. 





Ensemble Training 하기


- Model을 만든다

- 각각의 독립된 Model 을 꺼내와서 학습을 시킨다. 




각각의 합치는 것으로 조화롭게 만들어 본다.  결과 중 가장 높은 값을 선택한다.




Tensorflow 코드에서 prediction은 최종 결과의 값들이다. 정확도가 0.9952 까지 올라간다. 







참조


- 김성훈 교수님의 Class, tf.layers, Ensemble 강좌

'AI Deep Learning > NN by Sung Kim' 카테고리의 다른 글

[RNN] Basic & Training 하기  (0) 2018.07.11
[RNN] Recurrent Neural Network 개념  (0) 2018.07.11
[CNN] Class, tf.layers, Ensemble  (0) 2018.07.11
[CNN] MNIST 99% 도전  (0) 2018.07.11
[CNN] Tensorflow CNN 기본  (0) 2018.07.11
[CNN] Convolution Neural Network  (0) 2018.07.10
posted by peter yun 윤영식
2018. 7. 11. 14:53 AI Deep Learning/NN by Sung Kim

MNIST 99% 도전 강좌를 정리한다. 






Simple CNN Tensorflow 코딩


Convolution Layer 2개와 Fully-conntect Layer를 코딩한다. 




Conv layer 1 만들기


- 784 개 값을 가진다. None 은 n개 이미지

- reshape 28x28x1로 만듦

- X image가 입력

- filter 3x3x1 로 하고, 32개 filter를 만듦

- filter의 stride 1 로 한다. 

- L1  출력은 input image사이즈가 동일하게 나옴 (padding SAME)

- relu 통과 시킨후 max_pooling한다. 2 stride 여서 최종결과는 14x14x32 로 나옴



Conv layer 2 만들기 


- 14x14x32 최종결과를 입력으로 사용한다.

- 64 개 filter를 사용한다. 1 stride 사용

- relu 사용하고 max_pool통과 한다. 2 stride 이므로 size는 7x7x64가 된다. 

- Fully conntected 넣기 전에 reshape 한다. 최종 3136 개가 된다.  





Fully Connected (FC, Dense) Layer 만들기 


- hypothesis를 만든다. 




학습(Learning) 시키고 테스트하기 


- 에폭(epoch) 단위로 학습 

- cost, optimizer를 수행

- 0, 1을 true, false로 나누어 계산

- 정확도: 0.9885







더 많은 Conv Layers


Conv layer 3개 FC 2개를 사용한다. 




- 정확도: 0.9938 로 높아진다. 

- dropout은 학습시 0.5~0.7 로 테스트시에는 1로 해야 한다. 






참조


- 김성훈교수님의 MNIST 99% 도전 강좌

posted by peter yun 윤영식
2018. 7. 11. 14:31 AI Deep Learning/NN by Sung Kim

Tensorflow CNN 기본 강좌를 정리한다. 





CNN 정리


Image와 Text 인식에 특출하다

- Convolution layer를 만들고

- pool sampling을 하고 

- 특징을 뽑아내고 (feature extraction)

- FF 로 classification 한다. 



예) 3x3x1 image에서 2x2x1 filter 로 맨뒤 이미지와 같은 색 1을 갖는다. filter가 stride가 움직이며 1개의 값을 뽑아낸다. ]






Tensorflow 코드 이해


[1, 3, 3, 1] : 맨 앞은 한개의 이미지만을 사용하겠다. 3x3x1 의 image를 시각화 하면 imshow를 사용해 만들 수 있다. 



이것을 Simple Convolution layer로 만들어 시각화 하면

- filter size만큼 안에 있는 것을 더 함.




- stride가 1만큼 움직이며 다음 값을 더 함. 




Convolution을 직접 그리지 않고 Tensorflow 수식으로 표현할 때 conv2d를 사용한다.







Padding


SAME: convolution layer를 실제 image와 같은 사이즈가 되게 만든다.  즉, INPUT과 OUTPUT size를 같게한다. 



Tensorflow로 구현하면 



Filter를 여러개 사용할 경우, 1장의 image로 부터 3장의 filter 이미지가 나온다. 







Max Pooling


데이터를 줄여서 sub sampling을 하는 것이다. max_pool을 사용한다. max_pool이 CNN가 잘 동작한다. 







실제 이미지로 테스트 하기 


데이터를 읽어오고, 28x28 사이즈의 image를 읽는다. 



Convolution Layer를 만든다. 

-  -1은 n개의 image 읽음. 3x3 filter size, 5개 filter 사용, 2 stride, SAME padding

- filter 5개 이므로 이미지가 5개 이다. 2 stride 여서 결과는 14x14 이다.




max pooling을 수행한다. 14x14에 대한 2 stride를 하면 결과는 7x7이 나온다. 이미지가 sub sampling되어 이미지 해상도가 떨어져 있다.






참조


- 김성훈교수님의 Tensorflow CNN 기본 강좌

'AI Deep Learning > NN by Sung Kim' 카테고리의 다른 글

[CNN] Class, tf.layers, Ensemble  (0) 2018.07.11
[CNN] MNIST 99% 도전  (0) 2018.07.11
[CNN] Tensorflow CNN 기본  (0) 2018.07.11
[CNN] Convolution Neural Network  (0) 2018.07.10
[Neural Network] Softmax에 NN 적용하는 순서 팁  (0) 2018.07.09
[Neural Network] 종류  (0) 2018.07.09
posted by peter yun 윤영식
2018. 7. 10. 16:56 AI Deep Learning/NN by Sung Kim

Convolutional Neural Network 강좌를 정리한다.





Convolutional Neural Network


하나의 입력이 계속 여러개인 경우는 fully Connected Network 이고 여러 입력 Layer를 가지고 있는 경우를 CNN이라 한다. 



CNN은 고양이가 이미지를 받아들이는 것이 한조각씩 나누어서 인지하고 이것을 합치는 실험에서 출발한다. 





CNN 처리과정


일정 부분을 처리하는 것을 filter라 부른다. 예로 32x32x3 image를 5x5x3 사이즈로 필터링한다. 그러면서 이 작은 이미지를 전체 이미지를 이동하며 Wx+b를 수행한다. 



이것을 이동해 가는 것을 그림으로 그려본다. 한칸을 Stride라고 한다. 2 stride는 두칸이 이동함을 의미한다. 



CNN을 사용할 때는 pad(모서리) 라는 개념을 사용함. 7x7 에 패딩을 줌으로 9x9가 된다. 하지만 INPUT과 OUTPUT은 7x7로 같아진다. 







Max Pooling 


pool을 sampling이라고 보면된다. 


각 한 Layer에 대해 크기를 줄여서 sampling한다. max pooling은 layer안에서 가장 큰값을 고르는 것이다. 



CONV -> ReLU -> POOL ==> 최종: FC (Fully Connected Layer)




ConvNet 활용 예


라쿤 교수의 LeNet




AlexNet


처음  ReLU사용 in ImageNet



GoogLeNet


2014년에 시도 



ResNet


2015년에 나옴. 많은 대회를 휩쓸면서 최강좌 자리차지함. 152 Layer를 사용한다. Fast Forward를 사용하여 학습하는 Layer를 줄여줌.





2014년 Yoon Kim 


Text에 대한 Classification이 가능해짐




그리고 CNN을 사용한 DeepMind사의 알파고가 있다. 





참조


김성훈교수님의 CNN 소개 강좌활용 예 강좌

ConvNetJS 데모를 통해 시각화



'AI Deep Learning > NN by Sung Kim' 카테고리의 다른 글

[CNN] MNIST 99% 도전  (0) 2018.07.11
[CNN] Tensorflow CNN 기본  (0) 2018.07.11
[CNN] Convolution Neural Network  (0) 2018.07.10
[Neural Network] Softmax에 NN 적용하는 순서 팁  (0) 2018.07.09
[Neural Network] 종류  (0) 2018.07.09
[Deep Learning] Dropout 과 앙상블  (0) 2018.07.09
posted by peter yun 윤영식

NN의 MNIST 98% 이상 올리기 강좌를 정리한다. 





일반 Softmax MNIST 예


정확도: 0.9035

softmax에 대한 개념 정리를 참조하면 Softmax는 결과 Label을 모두 합치면 1되도록 0과 1사이의 값으로 나오게 한다. 확률(Probability) 의미








일반 Softmax를 NN으로 구성하기 


정확도: 0.9455

Neural Network Layer를 3단 정도 구성해 준다. 이때 ReLU를 사용한다. 






Xavier사용한 초기화 잘 하기


정확도: 0.9783

샤비어(Xavier)를 적용한다. 구글 검색 "Xavier Initialization Tensorflow" . Xavier를 쓰면 처음부터 Cost값이 상당히 낮다. 이것은 초기값을 잘 썼음을 나타낸다. 


모델은 바꾸지 않고 초기값만 바꾸었을 때의 비교






깊고 넓게 적용할 때 Dropout 사용하기


정확도: 0.9804

깊게 사용시 중간의 값을 더 많이 쓴다. Overfitting이 발생할 수 있으므로 Dropout으로 이를 예방한다. 한 Layer에 대해 Dropout을 한다. 

dropout하지 않고 깊고 넓게 했을 때, 정확도가 0.9783보다 낮게 나온다. 네트워크가 깊어지면 학습된 것을 모두 기억해서 나중에 overfitting을 일을킬 수 있다. 이경우는 정확도가 낮아져서 Overfitting된 것이다. 



dropout시 몇 %를 Keep (학습 내용을 기억)할 것인지 - keep probability - 은 0.5~0.7 을 사용한다. 단, 테스트할 때는 1을 사용한다. 







Adam Optimizer 사용하기


기존은 GradientDescentOptimizer를 사용하였다. 여러 종류의 Optimizer가 있다.



ADAM이 Cost를 빠르게 감소시켜준다. 



공식






결론


최근은 입력값을 Normalization을 잘 하는 것도 사용한다. 



CNN을 사용하게 되면 Accuracy가 99%까지 올라간다. 






참조


- 김성훈교수님의 NN의 98% 정확도 올리기 강좌

- Xavier Initialization Tensorflow 구글 검색 첫번째

- Softmax 정리글 (강추)

posted by peter yun 윤영식

레고처럼 넷트웍 모듈 만들기 강좌를 정리한다. 





Fast Foward


이전 Layer의 결과를 n layer 앞읠 input값으로 사용한다. 예) 2015년도 Image Net




Split & Merge


나누어서 합치거나, 처음부터 나누어서 나중에 합침등





Recurrent network


밑에서 위로 가면서 옆으로도 확장됨



오직 개발자의 상상력으로 CNN, RNN, FF등을 사용하여 NN을 구축해서 할 뿐이다.





참조


- 김성훈교수님의 네트웍 모듈 만들기 강좌

- Machine Learning 용어 정리

posted by peter yun 윤영식

Dropout과 앙상블 강좌를 정리한다. 





Overfitting의 제거


데이터를 꼬부리는 것: 아는 것을 넣었더니 accuracy가 0.99 였지만 한번도 못지 못한 것을 넣을 때 accuracy가 0.85로 낮으면 이것을 overfitting되었다고 한다.



Training Accuracy와 Weight n layer 관계도 


overfitting이 되면 layer가 늘어날 수록 training은 잘되는 것 같지만 일정 시점에 test dataset의 정확도는 떨어지고 있다. 




Overfitting 제거 방법


- 학습데이터를 더 많이 사용한다.

- Regularization을 사용한다. W의 제곱의 최소화 => L2 Regularization


- Dropout: Neural Network 에서 사용하는 방법, 그만두기(Dropout), 학습시에 Neural Network을 끊어버리자. Random하게 어떤 뉴런들을 제거하고 나머지를 가지고 훈련시킨다. 그리고 최종적으로 dropout시킨 것을 다 사용해 예측한다. (상당히 잘 된다.)


수식을 사용하면 다음과 같다.

- 훈련시에만 dropout_rate을 주고, 테스트/평가 시에는 1로 주어야 한다.






Ensemble (앙상블, 언셈블)


여러 모델을 만들어 보고 이것을 합친다. 성능향상을 높일 수 있다. 실전에서 앙상블 모델을 사용하면 좋다.

 






참조


- 김성훈교수님의 Dropout과 앙상블 강좌

- Ensemble Concept

posted by peter yun 윤영식

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





Deep Network의 문제점


- sigmoid를 ReLU(렐루)로 변경

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


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

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







RBM (Restricted Boltzmann 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 윤영식