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

Publication

Statistics Graph

Recent Comment

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





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
[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 peter yun 윤영식

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] 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 peter yun 윤영식

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
[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
posted by peter yun 윤영식

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

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 윤영식
prev 1 2 3 4 5 6 7 ··· 96 next