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

Publication

Category

Recent Post

2018. 11. 25. 18:05 AI Deep Learning

자연어 처리 강좌를 정리한다. 





개념


- 문장을 분해하여 관계를 만들어 주어야 한다. 

- 데이터를 서로 연결하다보면 2차원 이상으로 발전한다. 

- 자연어는 모델링은 쉽지만, 전처리와 결과의 해석이 중요한다. 결과에 따른 해석이 따라 의미가 틀려진다. 이는 이미지/음성과 틀린 부분이다.

- 음운론, 형태론, 통사론, 의미론, 추리론

- Document -> Tokenizing -> Streaming/Tagging (컴퓨터가 이해하는 방식으로 배치하기) -> 최종 Word2Vec 에서 사용함




Tokenizing


- 구글 Colab을 사용한다.

- Token: document에서 쓸만한 것들로 의미를 같는 문자열 -> Tokenizing

- Colab에서 필요한 모듈 설치하기 in ubuntu

! apt-get update

! apt-get install g++ openjdk-8-jdk 

! pip3  install  nltk konlpy wordcloud matplotlib gensim 


! apt-get install fonts-nanum*

! apt-get install fontconfig

! fc-cache -fv

! cp /usr/share/fonts/truetype/nanum/Nanum* /usr/local/lib/python3.6/dist-packages/matplotlib/mpl-data/fonts/ttf/

! rm -rf /content/.cache/matplotlib/*


- import nltk # Natural Language ToolKit 사용

  + sent_tokenize, word_tokenize

- import re  #정규표현식 사용

// 패키지 사용

text = """갤럭시(GalaxyNote9)노트9. 2018년 08월 폭발적인 인기를 이끌고 있습니다. 

담당자 010-222-9999. 홍보팀 010-8888-9999"""

from nltk import sent_tokenize, word_tokenize, FreqDist

sent_tokenize(text)

tokens = word_tokenize(text)


// 정규표현식

import re

tokenizer = re.compile(r'[가-힣]+')

tokenizer.findall(text)




Stemming & Tagging


순서 Tokenizing -> Stemming -> Tagging을 한다. 일반/평문이 결과값이 잘나오고, 강조문/도치문/압축문은 일반/평문으로 만들어하는게 좋다. 


Stemming: 정규화

- 토큰의 어근/어간 추출

- 가능한 비슷한 의미 형태로 묶어주기 => 원형화한다

   예) 가다, 가니, 가고 => 가- 

         산뜻하다, 산뜻하니, 산뜻하고 => 산뜻하-


Tagging: 문법/Filter

- Token별 높은 확률의 태그(속성값/문법)을 추가 

- 단어의 품사별로 묶음: 동사, 명사, 부사


// 토큰

text = "Don't hesitate to ask question"

from nltk.tokenize import TreebankWordTokenizer

tokenizer = TreebankWordTokenizer()

token = tokenizer.tokenize(text)


// 태그

from nltk import pos_tag

pos_tag(token)


// 한글처리

// 테크

from konlpy.tag import Okt

twitter = Okt()

twitter.pos('서울R&D캠퍼스 수업자료')


//토큰, 스테밍을 같이 처리 stem === stemming

text = "워런 버핏은 삼성전자가 아닌 애플주식을 왜 샀을까"

print(twitter.pos(text, stem="true"))




Word Cloud로 시각화하기


- Visualization (시각화)

- 연설문을 워드클라우드로 표현하기 

// 필요 모듈 설치

! apt-get update

! apt-get install g++ openjdk-8-jdk 

! pip3  install  nltk konlpy wordcloud matplotlib gensim 


! apt-get install fonts-nanum*

! apt-get install fontconfig

! fc-cache -fv

! cp /usr/share/fonts/truetype/nanum/Nanum* /usr/local/lib/python3.6/dist-packages/matplotlib/mpl-data/fonts/ttf/

! rm -rf /content/.cache/matplotlib/*

speech_text = "https://raw.githubusercontent.com/YongBeomKim/nltk_tutorial/master/data/pyongyang_fin.txt"

script_text = "https://raw.githubusercontent.com/YongBeomKim/nltk_tutorial/master/data/movie_memories_of_murder_2003.txt"

font_file = "/usr/local/lib/python3.6/dist-packages/matplotlib/mpl-data/fonts/ttf/NanumGothicCoding.ttf"


// 워드클라우드 사용

import requests

import pandas as pd

import matplotlib.pyplot as plt

from wordcloud import WordCloud

from nltk import FreqDist

from nltk.tokenize import word_tokenize

import nltk

nltk.download('punkt')


texts = requests.get(speech_text).text

texts[:100]


// 그리기 

%matplotlib inline

wcloud = WordCloud(font_file).generate(texts)

plt.figure(figsize=(12,12))

plt.imshow(wcloud)

plt.axis('off')


명사만을 사용하여 word cloud 표현

from konlpy.tag import Okt

twitter = Okt()

tokens = twitter.pos(texts, stem=True)

tokens_noun = [token[0] for token in tokens if token[1] == 'Noun']

texts_noun = " ".join(tokens_noun)

texts_noun[:300]




Deep Learning 수행


Natural Language Processing + Deep Learning을 결합하여 챗봇을 만들어가기

  - RNN, LSTM, GRU가 챗봇만드는 기본 알고리즘

  - Data 입력/전처리 (Train Data) -> Cell 선택 및 모델 구성 -> Training / Modeling / Validation -> Model 평가 

  - Input -> Hidden Layer -> Output

  - Input Data 를 구성하는 Word2Vec


Word2Vec는 문장에 따라 데이터를 구조화한다. 

  - 하나의 중심데이터와 주변데이터로 구분함. 

  - 단어간 유사도 검사

  - 구조자체가 작아서, 딥러닝이라 할 수 없다. 

  - 로지스틱 회귀식(2 Cell)을 통해 분류한다. 

  - Corpus (말뭉치) -> Vocabulary Builder -> Context Builder -> Input -> Output 

  


새로운 방식

  - Input 하나에 Output 여러개를 통해 학습 => Skip-gram (sg)

  - try -> error를 통해 맞는 길로 찾아는 방식

과거 방식

  - Input 여러개에 대한 Output 으로 중심 단어 하나 => CBOW (Content Back of Word)


     



실습


  - 20차원의 구조를 만든다. 

  - Dimension(차원)안에 토큰을 넣는다. 비슷한 토큰은 같은 차원에 넣는다. 

  - 빈도수가 적은 것은 하나의 차원에 묶는다. 이안에 빈도수가 높은 것은 중심축에 놓는다. 

    



- size: 차원 30개 (중요)  <== 실습 단어가 151개여서 유의미화를 위해 30차원으로 줄여서 설정했음.

- window: 주변 데이터

- min_count: 10번이상 등장한 단어만 (중요)

- hs: ?

- workers: cpu parallel 동작

- sg: skip-gram

// 전처리후 

...

// 명사 저장

sentences = txtnoun(sentences, skip=skips, tags=["Noun"])

script_file = 'scripts.txt'

with open(script_file, 'w', encoding="utf-8") as file:

   file.write(sentences)


// gensim 이용 모델 만들기

%%time

from gensim.models import word2vec

data = word2vec.LineSentence(script_file)

model = word2vec.Word2Vec(data, size=30, window=2, min_count=10, hs=1, workers=4, iter=100, sg=1)

model_file = "script.model"

model.save(model_file)


결과

CPU times: user 1.59 s, sys: 113 ms, total: 1.71 s, Wall time: 1.7 s


// 모델의 단어수 

model = word2vec.Word2Vec.load(model_file)

len(model.wv.vocab.keys())

list(model.wv.index2word)


결과

151 


// 근접 백터값 확인하기, 참깨밭을 제거하고 추출해 봄

model.wv.most_similar(['현장','백광호'], negative=['참깨밭'], topn=20)


30차원을 시각화하기 위해 skitlearn의 TSNE를 이용해서 2차원으로 변경해서 표현한다. 




<참조>

- 강좌 슬라이드, 전체 실습 파일

- 정규 표현식 정리, 실습하는 서비스

KoNLP

- Word2Vec 관련 이론

posted by 윤영식
2018. 8. 22. 14:40 AI Deep Learning/Tensorflow

이찬우님의 텐서플로우 유튜브강좌를 정리한다. 




강좌 3


로지스틱 비용함수를 만들기

  - 좌측과 우측에 대한 convex 를 만들기 위한 식

cost = tf.reduce_sum(-y*tf.log(output)-(1-y)*tf.log(1-output), reduction_indices=1)


prediction과 label끼리의 정확도를 판단하기 

  - 각자의 벡터 매칭이 맞으면 1, 틀리면 0으로 하는 값을 다시 n*1 벡터로 만든다. 

  - 해당 백터의 값에 대한 평균을 구한다. 

  - 이때 1, 0값은 bool이어서 float32로 변환하여 계산한다.

  - 잘 맞으면 평균 1 이 나온다. 

comp_pred = tf.equal(tf.argmax(output, 1), tf.argmax(y, 1))

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


모델 저장하기

  - Training시킨 모델을 저장하는 것을 Checkpoint라 한다.

  - 저장내용에는 Weight과 Model이 저장될 수 있다. 

  - Weight관련 Variable을 저장한후 Save한다.

  - 저장시 유의점은 Variable, placeholder 함수의 파라미터중 하나인 Name이 자동으로 지정된다. 

W_o = tf.Variable(tf.truncated_normal(shape=[HIDDEN2_SIZE, CLASSES], dtype=tf.float32))

b_o = tf.Variable( tf.zeros([CLASSES]), dtype=tf.float32)


param_list = [W_h1, b_h1, W_h2, b_h2, W_o, b_o]

saver = tf.train.Saver(param_list)


hidden1 = tf.sigmoid(tf.matmul(x, W_h1) + b_h1)

hidden2 = tf.sigmoid(tf.matmul(hidden1, W_h2) + b_h2)


....

for i in range(1000):

    _, loss = sess.run([train, cost, accuracy], feed_dict = feed_dict)

    if i % 100 == 0:

        saver.save(sess, './tensorflow_3_lec.ckpt')

        ...




강좌 4


저장된 Weight Restoring하기 

  - save 할 때 Widget의 Variable에 name을 지정한다. 

  - 

x = tf.placeholder(tf.float32, shape=[None, INPUT_SIZE], name='x')

y = tf.placeholder(tf.float32, shape=[None, CLASSES], name='y')

W_h1 = tf.Variable(tf.truncated_normal(shape=[INPUT_SIZE, HIDDEN1_SIZE], dtype=tf.float32), name='W_h1')

b_h1 = tf.Variable(tf.zeros([HIDDEN1_SIZE]), dtype=tf.float32, name='b_h1')

hidden1 = tf.sigmoid(tf.matmul(x, W_h1) + b_h1, name='hidden1')

hidden2 = tf.sigmoid(tf.matmul(hidden1, W_h2) + b_h2, name='hidden2')

output = tf.sigmoid(tf.matmul(hidden2, W_o) + b_o, name='output')

...

saver.restore(sess, './tensorflow_3.ckpt')




강좌 5


Tensorboard는 디버깅 용도이다. 공식 튜토리얼을 참조한다.

  - name_scope는 묶음 단위이다.

  - scalar: 로그 데이터 남기기

  - tf.summary.merge_all()

  - tf.summary.FileWriter(<dir>, session.graph) 

# 가설함수 

with tf.name_scope('hidden_layer_1') as h1scope:

    hidden1 = tf.sigmoid(tf.matmul(x, W_h1) + b_h1, name='hidden1')


with tf.name_scope('hidden_layer_2') as h2scope:

    hidden2 = tf.sigmoid(tf.matmul(hidden1, W_h2) + b_h2, name='hidden2')

    

with tf.name_scope('output_layer') as oscope:

    output = tf.sigmoid(tf.matmul(hidden2, W_o) + b_o, name='output')


....


# 수행 

sess= tf.Session()

sess.run(tf.global_variables_initializer())


merge = tf.summary.merge_all()


for i in range(1000):

    _, loss, acc = sess.run([train, cost, accuracy], feed_dict = feed_dict)

    if i % 100 == 0:

        train_writer = tf.summary.FileWriter('./summaries/', sess.graph)


$ tensorboard --logdir=./summaries 수행한다. 




강좌 6


Loading Data in Tensorflow 참조. CSV파일 읽기

  - decode_csv로 콤마기반의 csv파일을 읽어들인다.

  - record_defaults = [[1], [1], [1], [1], [1], [1], [1], [1], [1]]  Fixed 자리수에서 비어있는 값에 대한 default value이다. 

  - start_queue_runners는 Session.run이 수행되기전에 호출해서 queue를 실행해서 file이 queue에서 대기토록 한다.

  - Coordinator 는 Thread 관리를 수행한다.

!

Image 읽기

  - FixedLengthRecordReader로 읽음

  - decode_raw를 사용함




to be continue...




<참조>

  - 텐서플로우의 체크포인트 설명

  - 텐서플로우 Save & Restore

  - 파이썬의 With 구문 이해 





posted by 윤영식
2018. 8. 21. 16:52 AI Deep Learning/Read Paper

Data2Vis 논문에 대한 개념을 알아본 후 다른 곳에 응용을 하려면 어떻게 어떤 단계를 거쳐서 진행해야 할지 실험을 해본다. 




준비


컴파일 환경

Python v3.7

Tensorflow v1.9

Anaconda기반에서 구동한다.




Step-1) 모델 환경설정


train_options.json 에 정의된 Model의 파라미터 내용

  - Data2Vis는 Attention 메카니즘을 가지는 Encoder-Decoder 아키텍쳐이다. 

  - 2-layer bidirectional RNN encoder/decoder를 사용한다.

  - GRU보다 LSTM이 보다 좋은 성능을 나타내서 LSTM을 사용한다. 


Loss(Cost)와 Training 함수를 포함한 모델(Model)은 AttentionSeq2Seq를 사용하고, 해당 모델에 대한 환경설정 파일은 example_configs/nmt_large.yml에 정의되어 있다. 

  - 데이터: source와 target 정보의 위치를 지정한다. 

  - 가설/비용 함수: Encoder/Decoder 를 구성하고 inference 파라미터등도 설정한다. Encoder/Decoder의 Cell은 LSTMCell을 사용한다.

  - Training 함수: Adam optimizer 사용



Step-2) Data 전처리


모델을 Training시키기 위해서 Dataset의 Field를 numeric, string, temporal, ordinal, categorical등으로 분류를 해놓는다. 이에 대한 Output(Labeled)으로 Vega-lite문법에 맞추어 환경파일을 각각 만든다. 

  - sourcedata/*.sources 또는 *.targets 파일중에 dev.sources와 dev.targets를 보면 dataset의 index당 vega-lite spec을 매칭했다.

  - vega-lite문법에서 data 필드만 제외한다.

  - 총 3가 성격의 sources, targets를 준비한다.

    + dev

    + train

    + vocab

  - dataset의 필드를 특별히 str<index>, num<index> 로 변환한다.

  - 데이터 전처리를 위한 스크립트는 utils/*.py에 있다.

  - 데이터 전처리 전의 실데이터는 testdata/*.json에 vega-lite의 다양한 spec은 examples/*.json 에 있다.

//dev.sources 

[{"num0": 0, "num1": null, "str0": "Small", "str1": "AMERICAN AIRLINES", "str2": "AUSTIN-BERGSTROM INTL", "str3": "Approach", "str4": "Day", "str5": "None", "str6": "Unknown bird - small", "num2": 0, "str7": "MD-80", "str8": "8/1/95 0:00", "str9": "Texas", "num3": 0}]

[{"num0": 0, "num1": 140, "str0": "Small", "str1": "US AIRWAYS*", "str2": "CHARLOTTE/DOUGLAS INTL ARPT", "str3": "Approach", "str4": "Day", "str5": "None", "str6": "European starling", "num2": 0, "str7": "B-737-300", "str8": "7/19/99 0:00", "str9": "North Carolina", "num3": 0}]


//dev.targets
{"encoding": {"y": {"field": "str0", "type": "nominal", "selected": true, "primitiveType": "string"}, "x": {"type": "quantitative", "field": "num2"}}, "mark": "point"}
{"encoding": {"y": {"field": "str3", "type": "nominal", "selected": true, "primitiveType": "string"}, "x": {"type": "quantitative", "field": "num0"}}, "mark": "tick"}




Step-3) 모델 생성하기


모델 환경설정과 Training을 위한 source, target 데이터가 준비되었다면 모델을 생성한다. 

  - procject-directory 위치를 변경한다.

  - bin/train.py를 수행을 위한 파라미터이다.

  - vizmodel로 ckpt파일을 생성되므로 별도 지정을 해보자. (data2vis에 이미 생성된 ckpt가 존재한다.)



Step-4) 추론 검증


Data2Vis는 Model을 미리 ckpt로 저장해 놓았고, WebDemo가 존재한다. webserver.py 는 Flask로 구성하여 간단하게 다음의 작업을 수행한다.

  - 웹화면에서 Generate Example 버튼을 클릭하면 examplesdata/*.json에서 실제 dataset 을 random하게 읽어온다.

  - 실데이터의 field를 str, num으로 바꾸어 inference에 넣은후 Vega-lite spec를 output로 받는다.

  - 출력으로 나온 Vega-lite spec에 data 필드에 실데이터를 맵핑하여 최종 Vega-lite spec를 만들어 HTTP response를 한다. 

또는 command console에서 직접 수행해 볼 수 있다. 



<참조>


- 구글 
   tf-seq2seq 튜토리얼
   seq2seq NMT 튜토리얼

- Data2Vis 논문

posted by 윤영식
2018. 8. 16. 15:06 AI Deep Learning/Read Paper

Data2Vis는 seq2seq를 통해 입력되는 데이터를 기반으로 출력으로 차트를 자동생성한다.




개념


해당 논문을 이해하기 위해 다음과 같은 단어의 개념을 이해해야 한다. 소스에서도 같은 용어를 쓰기 때문에 소스이해를 위해서도 중요하다. 


 - Data2Vis의 데모 사이트에 가면 간략한 설명이 나와 있다.


    

  

  - Attention mechanism을 이용한 encoder-decoder 아키텍쳐 모델이다.  

  - key/value 쌍의 데이터를 입력으로 하고 Vega-Lite기반의 출력을 생성한다. Vega-Lite는 JSON기반으로 차트를 생성해주는 스펙이다. 

  - 특징

     + encoder는 최종 context vector 하나로 만든다. 이것을 C 라고 표현한다. 위이 그림에서 가운데 위치한 C이다. 

     + decoder는 학습할 때 encoder의 "C"와 "<go>답안"을 입력받아 "답안<eos>"를 출력하는 학습을 한다. (참조)

     + encoder, decoder의 길이를 정해야 한다. 무한정일 수 없다.

     + 여기서 encoder, decoder는 동시에 학습할 수 있다. (참조)

     + 정답이 있는 데이터만 S2S 학습이 가능하다.

     + 단어들에 대한 벡터화한 수치 사전이 필요하다. (참조)

  - beam search

     + RNN의 학습 과정에서 트리 탐색 기법으로 쓰임

     + 최고우선탐색(Best-First-Search)기번을 기본으로 회되 기억해야 하는 노드 수를 제한해 효율성을 높이는 방식

     + beam : 사용자가 기억해야 하는 노드 수

  - LSTM

     + Backward Propagation(역전파)할 때에 Gradient Vanishing이나 Exploding되는 현상을 막기 위해 LSTM을 사용한다. 

     + 역전파할 때 미분한다. Gradient는 결국 기울기 이고, 미분또한 기울기를 구하는 것으로 역전파를 할 때 미분의 값이 작을 때 Gradient Vanshing이 발생하고, 클때 exploding이 발생한다.

     + Gradient Vanishing에 대한 자세한 설명은 영덕의 연구소를 참조한다.  





소스 설치 및 실행


소스를 깃헙에서 클론한다.

$ git clone https://github.com/victordibia/data2vis.git


환경 설정

  - Anacoda를 설치

  - Python v3.6.5 사용

  - Tensorflow v1.9.0 사용 (Anaconda Navigator UI에서 설치하지 않고 conda CLI로 버전을 지정해서 설치한다.)

$ conda install -c conda-forge tensorflow=1.9.0


모듈 설치

  - requirements.txt는 node.js의 package.json역할

$ cd data2vis

$ pip install -r requirements.txt


실행하기 

$ python webserver.py


브라우져에서 http://localhost:5016/  호출


디버깅하기

MS Code에서 다음 항목을 추가한다.

  - port: listen 포트

  - model_dir: 모델이 있는곳, 이곳에 seq2seq의 환경파일인 train_options.json 파일이 존재해야 한다. 

     해당 파일은 training 시킨 결과를 통해 자동으로 생성된다. 훈련시키는 방법에 대해서는 두번째 글 참조.

  - beam_width: 사용자가 기억해야 하는 노드수 5개

{

    "version": "0.2.0",

    "configurations": [

        {

            "name": "Python: Data2Vis - Flask (0.11.x or later)",

            "type": "python",

            "request": "launch",

            "program": "${workspaceFolder}/webserver.py",

            "env": {

                "FLASK_APP": "${workspaceFolder}/webserver.py",

                "FLASK_ENV": "development"

            },

            "args": [

                "--port=5016",

                "--model_dir=vizmodel",

                "--beam_width=15"

            ]

        },

        {

            "name": "Python: Current File",

            "type": "python",

            "request": "launch",

            "program": "${file}"

        },

        .....

}


샘플 실행

  - 좌측 examples 메뉴를 클릭하고 입력창에 1이상의 값을 넣고, "Generate Examples" 버튼을 클릭하면 차트가 생성된다. 





seq2seq 모듈


구글이 개발한 tf-seq2seq 모듈 소스을 data2vis 폴더에 그대로 copy해 놓은 상태이다.  모델을 학습하고 검증하는 것은 실제 seq2seq가 하므로 tf-seq2seq 사용방법을 알아야 한다. 

   - tf-seq2seq 소개 블로그: Goolge NMT 논문 필수

   - seq2seq에 대한 기본 설명은 Arxiv의 Neural Machine Translation 논문을 참조한다. 

   - Tensorflow의 seq2seq 사용법



Configuration Training

  - 환경파일에는 Input data, model, training parameter를 정의한다.

  - vismodel의 train_options.json 파일을 사용한다.

  - optimizer 종류와 learning_rate등을 지정. Adam 옵티마이저를 사용.

  - vocab_target, vocab_source 임베딩을 위한 벡터 카운트를 만들기 위해 파일 지정

  - decoder, encoder class와 params을 설정. 둘 다 LSTMCell 사용

  - attention class와 params 설정

  - inference, bridge, embedding 설정

  - source/target.max_seq_len 으로 string의 크기 지정

  - 모델 옵션 설명

  - 인코더 옵션 설명

  - 디코더 옵션 설명


{

    "model_class": "AttentionSeq2Seq",

    "model_params": {

        "optimizer.name": "Adam",

        "decoder.class": "seq2seq.decoders.AttentionDecoder",

        "inference.beam_search.beam_width": 5,

        "decoder.params": {

            "rnn_cell": {

                "dropout_input_keep_prob": 0.5,

                "num_layers": 2,

                "cell_params": {

                    "num_units": 512

                },

                "dropout_output_keep_prob": 1.0,

                "cell_class": "LSTMCell"

            },

            "max_decode_length": 2000

        },

        "optimizer.learning_rate": 0.0001,

        "source.reverse": false,

        "source.max_seq_len": 500,

        "attention.params": {

            "num_units": 512

        },

        "attention.class": "seq2seq.decoders.attention.AttentionLayerDot",

        "vocab_target": "sourcedata/vocab.target",

        "target.max_seq_len": 500,

        "optimizer.params": {

            "epsilon": 8e-07

        },

        "bridge.class": "seq2seq.models.bridges.ZeroBridge",

        "vocab_source": "sourcedata/vocab.source",

        "encoder.params": {

            "rnn_cell": {

                "dropout_input_keep_prob": 0.5,

                "num_layers": 2,

                "cell_params": {

                    "num_units": 512

                },

                "dropout_output_keep_prob": 1.0,

                "cell_class": "LSTMCell"

            }

        },

        "encoder.class": "seq2seq.encoders.BidirectionalRNNEncoder",

        "embedding.dim": 512

    }

}



Training 

  - 모델과 교육데이터가 갖추어져 있으면 훈련을 수행한다.

  - /sourcedata안에 source, target의 trainig data가 존재한다.

  - utils/data_gen.py에서 /examples 폴더의 vega spec을 읽어와 training data를 만들고 있다. 



Prediction

  - 모델 Training을 받은 후 예측을 시작할 수 있다. 

  - DecodeText 클래스를 사용하고, Input pipeline은 ParallelTextInputPipeline을 사용함. 

    + DecodeText는 모델 예측을 가져와 표준 출력으로 추력하는 작업을 수행함

    + DumpAttention과 DumpBeams을 이용해 모델 수행시 디버깅을 할 수 있다. 파일로 쓰는 것임.

    + input pipline은 데이터를 읽는 방법을 정의한다.



Decoding with Beam Search

  - 빔 검색은 번역 성능을 향상시키는 일반적으로 사용되는 디코딩 기술이다. 

  - 빔 검색은 메모리에 가설 또는 빔(beam)을 놓고 가장 높은 점수인 것을 선택한다. 



Evaluating specific checkpoint

  - Training을 통해 다양한 모델의 체크포인트를 저장한다.

  - BLEU (bilingual evaluation understudy)를 통해 번역 성능 평가. 

 


Checkpoint에 대한 설명

- Saving

  + model 을 만드는 코드 의존적인 포멧을 갖는다.

  + 체크포인트는 training하며 생성된 모델의 버전이다.

  + Estimator가 checkpoint를 model_dir 위치에 저장한다. 

  + events 파일은 tensorboard가 시각시에 사용한다. 

  + Saver를 통해 체크포인트를 Saving/Restoring 한다. 


checkpoint

events.out.tfevents.timestamp.hostname

graph.pbtxt

model.ckpt-1.data-00000-of-00001

model.ckpt-1.index

model.ckpt-1.meta

model.ckpt-200.data-00000-of-00001

model.ckpt-200.index

model.ckpt-200.meta


- Restoring

  + Estimator는 train()을 호출하면 model의 그래프를 model_fn()을 호출해서 생성한다. 

  + Estimator는 최근의 checkpoint를 통해 새로운 모델의 weight을 초기화 한다. 






webserver.py 이해


파이썬 웹서비스는 Flask를 이용한다.  data2vis/static 과 templates가 Flask운영을 위해 사용된다. 


webserver.py 실행 순서

- port, vizmodel, beam_width를 아규먼트를 받는다.

- vizmodel/train_options.json을 기반으로 TrainOption 오브젝트를 생성

train_options = training_utils.TrainOptions.load(model_dir_input)


- model params을 사용해 model class를 생성함. AttensionSeq2Seq.py (attension_seq2seq.py)

model_params = _deep_merge_dict(model_params, _maybe_load_yaml(model_params))

model = model_cls(params=model_params, mode=tf.contrib.learn.ModeKeys.INFER)


- inference task 생성. DecodeText 생성

if (str(tdict["class"]) == "DecodeText"):

        task = task_cls(tdict["params"], callback_func=_save_prediction_to_dict)


- ParallelTextInputPipeline pipeline 생성

input_pipeline_infer = input_pipeline.make_input_pipeline_from_def(

    fl_input_pipeline,

    mode=tf.contrib.learn.ModeKeys.INFER,

    shuffle=False,

    num_epochs=1)


- inference를 사용하는 (Tensorflow) graph 생성.

  + seq2seq/inference/inference.py에서 pipeline과 batch_size를 통해 input function을 만들고

  + input function의  feature와 label을 model의 파라미터로 사용해서 model의 build를 호출한다. 

predictions, _, _ = create_inference_graph( model=model, input_pipeline=input_pipeline_infer, batch_size=batch_size)


- Listen을 하고, Flask의 routing을 설정한다. "Generate Examples" 버튼 클릭시 호출 

  + test data를 사용한다. 

  + normalize를 해준다. (foward_norm, backward_norm)

  + decode result를 가지고 vega spec을 만들어 return한다. 

@app.route("/examplesdata")

def examplesdata():

    source_data = data_utils.load_test_dataset()

    f_names = data_utils.generate_field_types(source_data)

    data_utils.forward_norm(source_data, destination_file, f_names)


    run_inference()

    

    decoded_string_post = data_utils.backward_norm(decoded_string[0], f_names)


    try:

        vega_spec = json.loads(decoded_string_post)

        vega_spec["data"] = {"values": source_data}

        response_payload = {"vegaspec": vega_spec, "status": True}

    except JSONDecodeError as e:

        response_payload = {

            "status": False,

            "reason": "Model did not produce a valid vegalite JSON",

            "vegaspec": decoded_string

        }

    return jsonify(response_payload)





<참조>


  - Data2Vis 소개글, 깃헙 소스, Arxiv 링크

  - deeep 블로그
     seq2seq 에 대한 쉬운 설명글

     Attention 메카니즘설명 (소개한 Arxiv 링크)

  - ratsgo 블로그
     RNN과 LSTM 이해

     seq2seq를 이용한 뉴스 제목 추출하기
     설명에 대한 소스 (2018년 tensorflow 버전에 맞지않다)

     beam search 이해 in Recursive Neural Network

  - 구글 제공
     seq2seq 문서

  - Tensorflow의 seq2seq 한글 설명, 2014년 Arxiv에 소개된 seq2seq pdf

  - 라온피플 블로그
     RNN, LSTM, GRU 소개

  - 영덕의 연구소 블로그
     Gradient Vanishing 문제 개념

  - Naivsphere 블로그

    SGD (Stochastic Gradient Descent)에 대한 글

  - 카카오 IT 브런치
     BLEU: NMT 평가 방식 설명

  - skymind.ai

  - epoch, batch_size 용어 이해 (MNIST epoch, batch 설명)

posted by 윤영식
2018. 7. 31. 15:25 AI Deep Learning

인공지능 공부하기 위한 여정을 정리하고 계속 업데이트 한다.  하루에 2시간 이상 꼭 공부를 해야 강좌를 완료할 수 있다. 





Machine Learning & Deep Learning


김성훈 교수님의 인프런 강좌

   - 모두를 위한 딥러닝 - 기본적인 머신러닝과 딥러닝 강좌

   - 모두를 위한 딥러닝 - Deep Reinforcement Learning



앤드류응 교수님의 코세라 강좌

   - 머신러닝



머신러닝 Engineer 학습경로

 Machine Learning Engineer 커리큘럼


    + Supervised Learning: Hypothesis  set <-> DAG (비순환 그래프)를 만드는 과정
    + Disttribution: Binary classification (이진분류), Multicase classification (다중 분류), Linear regression (선형 회귀), Multimodal linear regression (다항 회귀)


  - 테리님 왈 다음과 같은 과정으로 공부하길 추천함
   <초급>
    - 조대협님의 머신러닝 블로그글 (내가 추가한 것임)
   <중급>


T 아카데미의 인공지능 강좌

   - 인공지능을 위한 머신러닝 알고리즘

     + 김성훈 & 앤드류응 교수님의 강좌수강 후 개념 정리용 (단, 수학공식이 많이 나옴, 수학방을 이용하자)

     + 설명중 회귀 모델에 대한 보다 자세한 설명

     + 설명중 우도(가능도-Likelihood) 자세한 설명



Microsoft의 데이터 과학 전문 프로그램

  - 필수 과목 11개

  - 과정당 12시간: 하루 2시간 계산하면 과정당 1주가 걸림 -> 총 11주 프로그램     

  - 필요한 것을 선별해서 보면 좋을 듯함.




Interactive Data


Python 배우기

  - T 아카데미의 Python 프로그래밍: 파이썬 3 기반 기초 

  - T 아카데미의 Python을 활용한 데이터분석 기초: Jupyter Notebook기반으로 Pandas, Seaborn 실습

  - T 아카데미의 Python을 이용한 데이터분석 실습

  - Edwith의 머신러닝을 위한 Python



Tensorflow 배우기 

  - Tensorflow 공식 홈페이지

  - 골빈해커의 텐서플로우 강좌

  - 이찬우님의 텐서플로우 유튜브 강좌

  - Tensorflow로 MNIST 실습 SlideShare



CNN 이해

  - 초보자가 이해하기 좋은 CNN 이해 SlideShare

  - CNN 스탠포드 강좌 - CS231n



RNN 이해

  - 초보자가 이해하기 좋은 CNN, RNN 이해 SlideShare

  - RNN LSTM 이해 - Colah




용어 이해

 - Softmax 이해

 - Activation Function 이해

 - Back Propagation 이해. 수식으로 설명, 코드로 설명

 - ReLu 이해: 역전파의 오류 방지

 - 알고리즘 복잡도 이해 - Big O == "최악의 경우(시간복잡도가 클 경우)에도 이 시간 정도면 된다" 라는 의미

 - Log 함수 이해

 - tanh 이해

 - LSTM 이해




To be continued... 


사실 계속 공부해도 감 잡기는 정말 힘들다. 프로젝트를 해봐야 뭐라도 하나 잡고 갈듯하다. 




<참조>

- 인공지능과 머신러닝 학습 경로

테리님 블로그

조대협님 블로그

- 조경현 교수님의 뉴욕댁 머신러닝 강좌 소개소스

- 조경현 교수님이 참조하였다는 머신러닝의 강의 자료

- 시그모이드 함수 설명

- Activation Function 설명

- 역전파(Backpropagation) 설명, 잘 이해해야 함 (Adnrej Karpathy), Andrej의 RNN 이야기

- 로그함수 설명

- 수학방로그함수 좀더 기초적 설명

- 수학 기호 명칭 - 수식을 볼려면 기호의 의미를 알아야 한다.

- 미분에 대한 쉬운 이해

- MNIST - yann.lecun.com

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

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

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





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