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

Publication

Category

Recent Post

2018. 7. 13. 16:10 AI Deep Learning/NN by Sung Kim

Q Network 강좌를 정리한다. 





Q Network 개념


실제 문제를 풀어가기에는 Q Table 구성 사이즈가 너무나 크다. 따라서 Network을 구성해서 푼다. 주어진 입력, 출력을 사용자가 조절하면서 State, Action주어 원하는 Output을 얻어낸다. 적은 table을 사용해서 원하는 결과를 얻어내는 것 



Gym Game에서 출력을 Action 4개로 보면 다음과 같다. 


상태만 주고 모든 가능한 액션을 얻어내자. 앞으로 아래 모델을 사용한다. 



 

비용에 대한 최소화를 공식화 하면 

- W: Weight, 

- y: 실제값

- cost: 비용




목표는 Optimal Q인 Q* 즉, y값을 구한다. Ws는 네트워크가 만들어낸 Q prediction이라 할 수 있다.  




Q hat을 붙이면 hat이 prediction을 의미한다. "시타 = 세타"를 weight 이다. 




이 알고리즘을 문장으로 풀어쓰면

- 초기 weight을 random하게 준다.

- 첫번째 상태를 준다. @(s) == 파이(에스) - one hot을 해준다.

- E-greedy를 사용해 가장 좋은 action을 취한다.

- 결과로 상태랑 reward를 준다.

- 학습을 한다. 


해당 알고리즘은 deep mind의 핵심 알고리즘이다. 코드화 하면



다음으로 학습을 시킨다. 



Yj값으 두개인데, Done이면 Rj이고, 중간 진행은 Rj + rmaxxQ(@=1,a:세타)이다. 

Q Network의 결과는 Q Table 보다 성능이 안좋다. 이를 좀 더 빠르게 할려면?

diverge(다이버즈): 분산되어 결과가 안 좋다의 뜻






DQN 개념 


강화학습의 가장 중요한 알고리즘이다. (강좌) 두가지 큰 문제는 2가지 이다. 



  - 샘플데이터간의 correlation: 샘플이 다양하지 않고 연관성(correlation)이 있다.   

  


  - target이 흔들린다. target은 Y Label 이다. 예) 화살을 쏘자 과녁이 움직이는 경우




DQN의 3가지 솔루션


1) Go deep

네트워크가 깊게 갈 수록 좋다. 


2) Experience replay

action의 state를 buffer에 저장한후 사용한다. D = buffer

 


buffer에서 random하게 가져오면 sample의 correlation을 해결할 수 있다. 



3) non-stationary targets 

타겟이 움직인다. 세타 Weight을 update하면 target도 움직인다. Target의 세타를 그대로 둔다. 두개의 Network에서 첫번째 Network에서 target을 가져와서 두번째 Network에서 사용한다. 




2015년 Deep Mind가 Nature에 연재한 논문 알고리즘






참조


- 김성훈 교수님의 Q Network 강좌

- 김성훈 교수님의 DQN 강좌

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

[Reinforcement Learning] 강화학습  (0) 2018.07.12
[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
posted by 윤영식
2018. 7. 12. 16:36 AI Deep Learning/NN by Sung Kim

강화학습 강좌를 정리한다.





RL 개념


환경(세상, Environment)에서 행동하는 액터(Actor)는 환경속에서의 상태가 변경됨. 매순간마다 잘했다 못했다는 보상(Reward)을 줌.

- 1997년 Tom Mitchell 나온 이야기이다. 

- 2013, 2015년에 부활함: 벽돌깨기 게임에서 사용




옛날 게임에 적용해서 학습해 보니 reinforcement learning이 사람보다 더 잘하더라~~~. 알파고가 deep-reinforcement-learning 사용한다. 

- 빌딩 에너지 관리

- 로보틱스

- 투자

- E-commerce 추천

- 광고 ads


Q = r + Q 수학 기본을 사용한다. Tensorflow/Python으로 실습가능 






OpenAI GYM Games


Agent가 움직이고, 상태와 보상을 받는다. gym 환경을 별도 제공한다. 




gym 코드






Q Learning


RL의 핵심이다. 

입력

  - 내가 있는 상태

  - 이런 행동을 할려고 합니다.

    Q(s, a) => s-state, a-action

출력

  - Q가 결과를 내줌




Optimal Policy = 파이*별표

Q가 있다고 가정했지만 Q를 어떻게 학습할 것인가가 중요 사항임.



==> r + maxQ(s1, a1)

r: reward

max: argmax

Q

s: state

a: action




Q값이 학습을 통해서 다음과 같이 생긴다. 



전체 Q 알고리즘 정리하면

- 그림처럼 Q(s,a) 테이블을 만들고 0으로 초기화 한다.

   

- state s 상태를 가져온다. 

- 끝날때까지 무한 반복하면서 action을 취하고 reward를 받으면서 S -> S1(prime)으로 이동한다. 

- Q 학습이 진행된다. 



r: 현재의 reward 값

maxQ(s1,a1): 다음에 얻을 수 있는 최고의 reward 값



Tensorflow 구현 코드 


-  Q table초기화: np.zeros

- env.reset() 현재의 상태값

- while not done 돌며 끝날때 까지 Q Learning(학습) 수행






Exploit vs Exploration


Exploit: 현재 있는 값을 이용한다.

Exploration: 모헙을 해본다.

예) 평일에는 가던곳을 하고 주말에는 안가보던 곳을 모험해 본다. 



E-greedy: exploration의 정도

Discounted future reward: 감마(0.9) 를 곱하여 미래의 reward를 줄여서 계산한다. 


Tensorflow code







참조


- 김성훈교수님의 강화학습 강좌

- 김성훈교수님의 Q Learning 강좌

- OpenAI GYM 설명

- 강화학습 이해하기

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

[Reinforcement Learning] Q Network  (0) 2018.07.13
[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
posted by 윤영식
2018. 7. 11. 17:13 AI Deep Learning/NN by Sung Kim

RNN Basic 강좌를 정리한다. 






RNN Basic


cell단위로 다루어 Tensorfllow 코딩으로 OUTPUT이 다시 INPUT으로 들어오게 한다. 

- xxxRNNCell 의 output 사이즈를 정해주고 cell을 만든다. 

- cell을 dynamic_rnn에서 cell을 실제 구동시켜본다. 


cell 학습: BasicRNNCell, BasicLSTMCell등을 바꾸어 사용할 수 있다.








Cell 만들기 



문자를 one hot encoding 을 이용해 vector로 표현한다. 

- input dimenstion

- hidden size를 우리가 정하기 나름에 따라 정해질 수 있다. 

위 두가지는 cell을 만들 때 정의하는 것이다. 




Tensorflow로 표현한다. 

- BasicLSTMCell 사용

- outputs, states를 얻음 

hidden_size 2여서 값은 2개의 shape 가 나온다. 






Unfold 풀어놓기


이것을 풀어서 (unfold) 보자.

- sequence_length 5는 unfold 5개 한다는 것이다. 입력데이터의 모양에 따라 결정된다. 



Tensorflow에서 h, e, l, o에 대한 변수를 만들어 np.array([h, e, l, l, o]..)를 생성한다. dimenstion 2개인 5개 output이 나옴. 이것은 입력을 줄 때 어떤 Shape이 나오는지 출력해 본 것이다. 







Batch Size 만들기



문자를 다양하게 주어 (Batch Size)를 여러개 넣어서 만들어 본다. 




Tensorflow 코드 






Hi Hello Training 시키기


h를 입력하면 다음은 i 나옴을 학습시킨다. 




훈련시킬 단어: "hihello" 에서 Unqiue한 Vocabulary를 만든다. 문자열에 대해 index를 표현한다. 해당 index를 one hot encoding으로 변환한다.



여기서 다음을 정한다.

- 입력 차원

- Sequence 갯수

- 출력(hidden) 차원

- Batch size 정하기 




Creating NN Cell 


cell의 size는 출력값 5로 정한다. 

- rnn_cell.BasicRNNCell(rnn_size)

- rnn_cell.BasicLSTMCell(rnn_size)

- rnn_cell.GRUCell(rnn_size)




RNN Parameters


output from the LSTM : hidden_size = 5 

one-hot size : input_dim = 5

one sentence : batch_size = 1

/ihello/ == 6 : sequence_length = 6



Data Creation 




Feed to RNN


None은 batch가 많아도됨을 의미. cell을 만들고, batch_size주고, dynmaic_rnn을 호출한다. 


Cost: sequence_loss


얼마나 Output이 정확한가를 sequence_loss를 사용하여 예측을 해본다. 예측값이 얼마나 좋은지를 loss값으로 알 수 있다. 



모델을 만든다. 


지금은 output을 간단히 logits에 넣어서 사용한다. 실제는 이렇게 사용하진 않는다. 


Training을 시킨다. 





결과


prediction한 charactor에 대해 시간이 지날 수록 그 다음 문자에 대한 예측(prediction) 이 높아진다. 





참조


- 김성훈 교수님의 RNN Basic 강좌

- 김성훈 교수님의 RNN Training 강좌

- RNN Basic, LSTM 이해

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

[Reinforcement Learning] Q Network  (0) 2018.07.13
[Reinforcement Learning] 강화학습  (0) 2018.07.12
[RNN] Recurrent Neural Network 개념  (0) 2018.07.11
[CNN] Class, tf.layers, Ensemble  (0) 2018.07.11
[CNN] MNIST 99% 도전  (0) 2018.07.11
posted by 윤영식
2018. 7. 11. 15:43 AI Deep Learning/NN by Sung Kim

RNN 기본 강좌를 정리한다. 






RNN 개념


음성인식, 자연어 같은 Sequence data일 경우 처리 네트워크

- 이전의 결과가 다음 series에 영향을 미쳐야 한다. 



해당 그림을 풀어 놓으면 결과 state가 다음 연산에 영향을 미침. Series data에 적합한 모델




계산식화 하면 

- old state (ht-1) 과 x를 input로 사용하여 new state (ht)를 구한다. 




가장 기초적인 (Vanilla) RNN을 만들때 Wx를 사용한다. tanh는 sigmoid다른 형태이다. 

- ht는 다음 rnn로 넘기는 값

- y는 w x ht하여 값을 구함




Weight값으 전체  cell에 나 똑같은 값을 사용한다.







RNN 예측 사용


예) 예제에서 helo를 넣었을 때 예측으로 hello 라고 예측하는 시스템을 RNN으로 만듦 



- h,e,l,o를 1또는 0값의 벡터로 만들고 이전과 현재를 계산한다. 처음에는 0을 사용한다. 


여기서 y값을 구한다. 

softmax의 label(결과)를 취한다. 두번째 자리는 error가 발생. output layer의 값을 가지고 learning 하고 예측을 한다. 

- language model - 연관 검색어 찾기

- Speech Recognition

- Machine Translation

- Conversation Modeling/Question Answering

- Image/Video Captioning

- Image/Music/Dance Generation



RNN을 어떻게 사용하느냐가 관건이다. 



Multi Layer RNN을 사용할 수도 있다.



RNN에서 Vanilla Model가 복잡하면

- Long Short Term Memory (LSTM)을 쓰거나

- GRU by Cho et al. 2014를 쓸수도 있다.





참조


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

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

[Reinforcement Learning] 강화학습  (0) 2018.07.12
[RNN] Basic & Training 하기  (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
posted by 윤영식
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] MNIST 99% 도전  (0) 2018.07.11
[CNN] Tensorflow CNN 기본  (0) 2018.07.11
[CNN] Convolution Neural Network  (0) 2018.07.10
posted by 윤영식
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 윤영식
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] Convolution Neural Network  (0) 2018.07.10
[Neural Network] Softmax에 NN 적용하는 순서 팁  (0) 2018.07.09
[Neural Network] 종류  (0) 2018.07.09
posted by 윤영식
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
[Neural Network] Softmax에 NN 적용하는 순서 팁  (0) 2018.07.09
[Neural Network] 종류  (0) 2018.07.09
[Deep Learning] Dropout 과 앙상블  (0) 2018.07.09
posted by 윤영식

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 정리글 (강추)

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

[CNN] Tensorflow CNN 기본  (0) 2018.07.11
[CNN] Convolution Neural Network  (0) 2018.07.10
[Neural Network] 종류  (0) 2018.07.09
[Deep Learning] Dropout 과 앙상블  (0) 2018.07.09
[Deep Learning] Weight 초기화 잘하기  (0) 2018.07.09
posted by 윤영식

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





Fast Foward


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




Split & Merge


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





Recurrent network


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



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





참조


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

- Machine Learning 용어 정리

posted by 윤영식

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 윤영식

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 윤영식

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 윤영식

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





미분


아주 작은 값을 대입하여 순간변화율을 구하는 것이다. 변화율은 기울기로 표현할 수 있다. 미분은 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 윤영식

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 윤영식

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 윤영식

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





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 윤영식

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 윤영식

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 윤영식

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 윤영식
prev 1 2 next