데블스캠프2017/DeepLearningDay

이스트소프트 AI Plus Lab

• 컴퓨터 비전
• 자연어 처리
• 악성코드 탐지
• 금융시장 예측

딥러닝의 원리

딥러닝의 이해

• 인공지능
  • 사람만큼이나 사람보다 똑똑한 기계
• 머신러닝
  • 더 많은 데이터를 더 빠르게 처리할 수 있지만, 처리 알고리즘은 사람이 만들어야 한다
  • 사람보다 똑똑한 기계를 만들기 위해 사람(생물)이 학습하는 방법을 모델링
  • 데이터로부터 경험적, 귀납적으로 만들어낸 알고리즘에 의해 추론
  • feature와 label
  • 더 좋은 feature들을 추출할 수 있다면, 더욱 쉽게 분류할 수 있다
  • feature engineering
    • 딥러닝 이전 머신러닝에서 반드시 수행되어야하는 작업
    • 사람이 정답을 더 잘 찾기 위한 특징을 찾아내고 (->도메인 전문가)
    • 사람이 데이터에서 그런 특징을 식별하고 추출하는 알고리즘을 설계하는 것 (->알고리즘)
  • 단일 층으로 분류가 불가능하다면, 분류가 가능할 때까지 공간을 변형시키면 된다
  • 즉, 다중 층을 사용하면 된다
• 딥러닝
  • 여러 층을 통째로 학습시키면(차원이 늘어나면)
  • 사람이 찾을 수 있는 특징보다 더 좋은 특징을 찾아 분류를 할 수 있다
  • 이 특징은 사람이 이해하기에는 어려울 수 있다
  • 더 어렵고 복잡한 문제를 해결할 수 있는데 이를 수용력이라 함
  • 딥러닝은 머신러닝 더 넓은 수용력을 가지는 학습 방법
  • 학습할 데이터가 충분히 많아야 더욱 정확하고 복잡한 특징을 추출할 수 있게 된다
• 딥러닝에 필요한 것들
  • 선형대수학
  • 확률과 통계
  • 다변수 미적분
  • 알고리즘, 최적화
  • 기타 등등
  • 정보이론(엔트로피 ..)
  • 기타 수학적 이론들

=== 딥러닝의 원리 1 - similarity ===

• • 딥러닝에서는 스스로 좋은 feature를 찾아가기 때문에 최대한 손실이 없는 데이터를 사용하는 것이 유리하다
  • 벡터의 유사도를 나타내는 방법
  • 유클리드 거리(두 벡터의 차이)
  • 코사인 유사도(두 벡터의 내적)
  • 하지만 유사한 데이터라고 해서 유사한 벡터인 것은 아니다
  • 이를 해결하는 것이 머신러닝의 핵심적인 목교
  • 입력층 벡터를 유사하게 -> 입력 데이터의 모델링
  • 마지막 은닉 층 벡터를 유사하게 -> 네트워크 모델링
  • Supervised Learning
  • 분류의 정답인 함수 값을 통해 어떤 데이터들이 분류가 같아야 하고, 분류가 달라야하는지
  • 기준을 가르치는 것
  • 뉴럴 네트워크를 학습한다는 것
  • 학습한다는 것은 정답과의 오차를 줄이는 방향으로 모델 파라미터를 수정해 나가는 것
  • 학습이 잘 된 후에는 어떤 입력에 대해 강하게 반응하려면 가중치가 그 벡터와 유사해 진다
  • 모델링
  • 더 적은 데이터를 가지고 더 적합한 학습을 시킬 수 있도록하는 것이 모델링
  • ex) CNN
  • 응용
  • 변종 악성코드의 탐지와 분류
  • 악성코드의 유사도
    • 메타데이터가 유사하다
    • 파일 구조와 내용이 유사
    • 코드 패턴, 행위 패턴이 유사
    • 사용하는 API가 유사
    • 개발자의 습관이 유사
    • 노리는 대상이나 취약점이 유사
    • 통신하는 대상이나 패킷이 유사
    • 압축, 난독화, 암호화, 패키지 방식이 유사
    • 악성 여부?
    • 정말 모든 악성 코드를 유사한가?
    • 정말 모든 정상 코드는 유사한가?
    • 정말 정상코드와 악성코드는 유사하지 않은가?
    • 탐지명
    • 보안 분석가들이 오랜 기간동안 악성코드를 분류
    • 유사한 악성코드를 같은 탐지명으로 분류할까?
    • 같은 탐지명으로 분류된 악성코드들은 유사할까?
    • 하나의 악성코드는 하나의 탐지명으로만 분류할 수 있을까?
    • 탐지명을 label로 학습을 시킨다 하더라도
  • 신종 악성코드의 탐지와 분류
    • 학습한 데이터의 유사한 악성코드가 없다
    • 학습한 훈련 데이터에 같은 분류로 분류된 악성코드가 없다

딥러닝의 원리 2 - Probability

• 변별 모델
  • classification, regression
  • 입력 데이터 x가 주어질 때, 간단한 응답 y를 결정
  • 조건부 확률을 사용
  • 조건부 확률의 함정
  • 조건부 활률 뒤집기
    • 수 많은 경우의 수가 존재하므로 직접 계산하는 것은 굉장히 어렵다
    • 결합 확률
    • x,y가 동시에 일어날 확률
    • 베이즈 정리에 의해 계산
    • 결합 확률을 계산
• 생성모델
  • y라는 속성을 같는 그럴듯한 x를 생성
  • 딥러닝을 활용하면 y뿐만아니라 대량의 x로부터 숨겨진 특징 z를 찾아낼 수 있다
  • 가르친 적 없는 x를 생성
  • 딥러닝 기반 생성모델 VAEs, GANs, Auto-Regressive model, DBNs, RBMs

~~(딥)~~러닝

[1]

이미지 분류기 

• 이미지 데이터를 각 픽셀에 대해 rgb로 표현
• 다른 시각에서, 다른 성질을 가진 같은 물체를 어떻게 같은 label로 분류할 것인가
• hard-code로는 분류기를 만드는 것이 불가능함

K Nearest Neighbor Classifier

• • 이미지를 학습하여 저장
  • 새로 들어온 이미지를 차이가 가장 작은 값을 통해 분류
  • 비교하는 방법
  • 픽셀값으 절대값 거리 계산
  • 이를 distance로 사용
  • 분류 시간이 linear하게 증가
  • CNN 모델에서는 학습시간은 증가하지만, 분류가 빠름
  • hyper parameter
  • L1 distance vs L2 distance
  • K?
  • 실험적으로 hyper parameter를 결정
    • 학습 데이터 중 일부를 validation data로 사용
    • cross-validation

Linear Classification

• 선을 그어 분류하는 방법
• non-parametric approach
  • KNN 등
• parametric approach
  • 선의 기울기를 사용하여
  • f(x, W) -> 분류
  • score function f = W*x + b = 점수의 벡터
• loss function
  • 학습 데이터에 대해 unhappiness를 측정하는 함수
  • loss function을 작게 만드는 과정 -> optimization
  • ex) SVM loss function
• softmax classifier
  • score = 특정 분류에 대한 normalized 되지 않은 조건부 확률
  • loss function = -log(normalized score)
• optimization
  • loss function을 최소화하는 W을 구하는 과정
  • random search
  • W를 랜덤하게 생성하여 찾은 W 중 가장 loss 값을 가지는 W를 선택
  • 낮은 정확도
  • gradient descent
  • 가능한 작은 h를 사용하여 gradient를 측정
  • loss가 작아지는 방향으로 점진적으로 접근

고래 등에 태운 텐서플로

https://goo.gl/M1zJVP

if(ubuntu version < 16) instead 18~20page

• command -> sudo apt install docker.io

without GPU(?) instead 22~23page

1. command -> sudo docker rm -f tensorflow
2. command -> sudo docker run -d --net=host --name tensorflow gcr.io/tensorflow/tensorflow
3. connect http://127.0.0.1:8888/
4. try login in webpage
5. command -> sudo docker logs tensorflow
6. copy link to browser like this in log -> http://localhost:8888/?token=00bca78fdb2b3ab7b23eab7105dc639dab72d021ecd5c54f <- copy link like this to browser/

fully_connected_feed.py

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import argparse
import os
import sys
import time

from six.moves import xrange
import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data
from tensorflow.examples.tutorials.mnist import mnist

FLAGS = None


def placeholder_inputs(batch_size):
    images_placeholder = tf.placeholder(tf.float32, shape=(batch_size,
                                                           mnist.IMAGE_PIXELS))
    labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size))
    return images_placeholder, labels_placeholder


def fill_feed_dict(data_set, images_pl, labels_pl):
    images_feed, labels_feed = data_set.next_batch(FLAGS.batch_size,
                                                   FLAGS.fake_data)
    feed_dict = {
        images_pl: images_feed,
        labels_pl: labels_feed,
    }
    return feed_dict


def do_eval(sess,
            eval_correct,
            images_placeholder,
            labels_placeholder,
            data_set):

    true_count = 0
    steps_per_epoch = data_set.num_examples // FLAGS.batch_size
    num_examples = steps_per_epoch * FLAGS.batch_size
    for step in xrange(steps_per_epoch):
        feed_dict = fill_feed_dict(data_set,
                                   images_placeholder,
                                   labels_placeholder)
        true_count += sess.run(eval_correct, feed_dict=feed_dict)
    precision = float(true_count) / num_examples
    print('  Num examples: %d  Num correct: %d  Precision @ 1: %0.04f' %
          (num_examples, true_count, precision))


def run_training():
    data_sets = input_data.read_data_sets(FLAGS.input_data_dir, FLAGS.fake_data)

    with tf.Graph().as_default():
        images_placeholder, labels_placeholder = placeholder_inputs(
            FLAGS.batch_size)

        logits = mnist.inference(images_placeholder,
                                 FLAGS.hidden1,
                                 FLAGS.hidden2)

        loss = mnist.loss(logits, labels_placeholder)

        train_op = mnist.training(loss, FLAGS.learning_rate)

        eval_correct = mnist.evaluation(logits, labels_placeholder)

        summary = tf.summary.merge_all()

        init = tf.global_variables_initializer()

        saver = tf.train.Saver()

        sess = tf.Session()

        summary_writer = tf.summary.FileWriter(FLAGS.log_dir, sess.graph)

        sess.run(init)

        for step in xrange(FLAGS.max_steps):
            start_time = time.time()

            feed_dict = fill_feed_dict(data_sets.train,
                                       images_placeholder,
                                       labels_placeholder)

            _, loss_value = sess.run([train_op, loss],
                                     feed_dict=feed_dict)

            duration = time.time() - start_time

            if step % 100 == 0:
                print('Step %d: loss = %.2f (%.3f sec)' % (step, loss_value, duration))
                summary_str = sess.run(summary, feed_dict=feed_dict)
                summary_writer.add_summary(summary_str, step)
                summary_writer.flush()

            if (step + 1) % 1000 == 0 or (step + 1) == FLAGS.max_steps:
                checkpoint_file = os.path.join(FLAGS.log_dir, 'model.ckpt')
                saver.save(sess, checkpoint_file, global_step=step)
                print('Training Data Eval:')
                do_eval(sess,
                        eval_correct,
                        images_placeholder,
                        labels_placeholder,
                        data_sets.train)
                print('Validation Data Eval:')
                do_eval(sess,
                        eval_correct,
                        images_placeholder,
                        labels_placeholder,
                        data_sets.validation)
                print('Test Data Eval:')
                do_eval(sess,
                        eval_correct,
                        images_placeholder,
                        labels_placeholder,
                        data_sets.test)


def main(_):
    if tf.gfile.Exists(FLAGS.log_dir):
        tf.gfile.DeleteRecursively(FLAGS.log_dir)
    tf.gfile.MakeDirs(FLAGS.log_dir)
    run_training()


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--learning_rate',
        type=float,
        default=0.01,
        help='Initial learning rate.'
    )
    parser.add_argument(
        '--max_steps',
        type=int,
        default=2000,
        help='Number of steps to run trainer.'
    )
    parser.add_argument(
        '--hidden1',
        type=int,
        default=128,
        help='Number of units in hidden layer 1.'
    )
    parser.add_argument(
        '--hidden2',
        type=int,
        default=32,
        help='Number of units in hidden layer 2.'
    )
    parser.add_argument(
        '--batch_size',
        type=int,
        default=100,
        help='Batch size.  Must divide evenly into the dataset sizes.'
    )
    parser.add_argument(
        '--input_data_dir',
        type=str,
        default=os.path.join(os.getenv('TEST_TMPDIR', '/tmp'),
                             'tensorflow/mnist/input_data'),
        help='Directory to put the input data.'
    )
    parser.add_argument(
        '--log_dir',
        type=str,
        default=os.path.join(os.getenv('TEST_TMPDIR', '/tmp'),
                             'tensorflow/mnist/logs/fully_connected_feed'),
        help='Directory to put the log data.'
    )
    parser.add_argument(
        '--fake_data',
        default=False,
        help='If true, uses fake data for unit testing.',
        action='store_true'
    )

FLAGS, unparsed = parser.parse_known_args()
tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

mnist.py

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import math

import tensorflow as tf

NUM_CLASSES = 10

IMAGE_SIZE = 28
IMAGE_PIXELS = IMAGE_SIZE * IMAGE_SIZE


def inference(images, hidden1_units, hidden2_units):
    with tf.name_scope('hidden1'):
        weights = tf.Variable(
            tf.truncated_normal([IMAGE_PIXELS, hidden1_units],
                                stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),
            name='weights')
        biases = tf.Variable(tf.zeros([hidden1_units]),
                             name='biases')
        hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)

    with tf.name_scope('hidden2'):
        weights = tf.Variable(
            tf.truncated_normal([hidden1_units, hidden2_units],
                                stddev=1.0 / math.sqrt(float(hidden1_units))),
            name='weights')
        biases = tf.Variable(tf.zeros([hidden2_units]),
                         name='biases')
        hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)

    with tf.name_scope('softmax_linear'):
        weights = tf.Variable(
            tf.truncated_normal([hidden2_units, NUM_CLASSES],
                                stddev=1.0 / math.sqrt(float(hidden2_units))),
            name='weights')
        biases = tf.Variable(tf.zeros([NUM_CLASSES]),
                         name='biases')
        logits = tf.matmul(hidden2, weights) + biases
    return logits


def loss(logits, labels):
    labels = tf.to_int64(labels)
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
        labels=labels, logits=logits, name='xentropy')
    return tf.reduce_mean(cross_entropy, name='xentropy_mean')


def training(loss, learning_rate):
    tf.summary.scalar('loss', loss)
    optimizer = tf.train.GradientDescentOptimizer(learning_rate)
    global_step = tf.Variable(0, name='global_step', trainable=False)
    train_op = optimizer.minimize(loss, global_step=global_step)
    return train_op


def evaluation(logits, labels):
    correct = tf.nn.in_top_k(logits, labels, 1)
    return tf.reduce_sum(tf.cast(correct, tf.int32))

딥러닝과 자연어 처리

자연 언어 처리

• 컴퓨터가 언어를 받아들이고 이해하여 다양한 작업들을 할 수 있게 하는 것
• 간단한 것부터 어려운 것까지 문제의 범위가 넒음

• 언어학 기반 : 분할(띄어쓰기, 형태소), 품사 태깅, 구문 분석(parsing)
• 분석 : 문서 분류, 감정 분석, 주제 모델링, 정보 추출
• 변형 : ppt참고 ~~너무 빨라 판서를 못함~~
• 대화

수준별 언어 특성들

음소 -> 형태소 -> 문법 -> 의미(영어)

• 음소(phoneme) 어떤 언어에서 의미 구별 기능을 갖는 음성 상의 최소 단위
• 형태소
• 문법(syntax)  : 문장(, 단락)을 품사 단위로 분해, 분석트리를 생성
• 의미(semantic) : 문장의 의미를 논리식으로 표현, 언어의 모호함을 제거

딥러닝과 자연언어처리

• 언어 데이터의 특징 : 불연속적인 심볼의 나열 샘플(문장)별로 길이가 다를 수 있음. 계층적, 재귀적인 구조를 지님
• 딥러닝은 매우 유연한 모델을 제공함
  • • CNN : 지역적 특성을 가진 데이터의 처리에 좋음(주로 이미지)
    • RNN : 연속된 데이터들의 처리에 좋음
    • RecursiveNN: 계층구조를 가진 데이터의 처리에 사용가능

CNN

• • • 다음 층의 노드가 이전 층 "일부"에만 연결되어 있음
    • 다음 층의 노드들은 같은 kernel로부터 만들어짐(= 똑같은 계수를 재사용)

RNN

*연속된 입력값에 대해 중간 층을 메모리처럼 보고 중간 층을 위한 계수를 재사용

딥러닝의 특징

• 데이터로부터 중요한 특징을 자동으로 학습
• 수준 별 언어 특성에 대한 통일된 형태 제공 - vector
• 음소 : 음성 특성을 벡터로 표현, 학습
• 형태소 : 접두사, 접미사, 어간 등을 벡터로 표현, 결합
• 문법 : 문장 내의 단어들을 벡터로 표현
• 의미: 문장이나 구를 벡터로 표현

• 언어를 특성이 다른 데이터(그림, 음성)와 같은 표현(vector)으로 나타냄으로 여러 데이터를 같이 사용한(multimodal model)의 구축이 쉬워짐

ESTsoft의 사례

• 문제 : 다양한 종류의 비정형적 주문 이력들로부터 올바른 상품명 찾기

   "생표고버섯 KG 국내산" -> 표고버섯, 국내산, KG
 => 문자열 비교? 전통적인 방식
건표고버섯 KG 국내산, 상품
느타리버섯 KG 국내산, 상품
새송이버섯 KG 국내산, 상품
양송이버섯 KG 국내산, 상품
표고버섯(생) KG KG 국내산
엄지새송이버섯 KG 국내산, D-2 KG
느타리버섯 KG 찌개용 KG 국내산

전체 350,000 건

• Deep learning 모델을 이용해 상품명을 찾음(= classification 문제)
  • • CNN 모델 사용(?)
    • RNN : 연속적 데이터들의 처리에 좋음, 불연속적인 심볼의 나열, 샘플(문장)별로 길이가 다를 수 있음

1. 입력 문자열의 자모 분해

1. Neural network model

• 식자재 검색 : 썬단무지 3kg 원형썰기

썬단무지, 무우, 국내산, 싱그랑 3KG PAC, 원형썰기
썬단무지, 무 국내산, NB 한아름 3KG PAC, 원형썰기
썬단무지, 무, 국내산, 일하, 3KG PAC, 원형썰기
썬단무지, 무, 국내산, 일하, 3KG PAC, 반달썰기
썬단무지, 무우, 국내산, 싱그랑, 3KG PAC, 반달썰기

Keras 실습

• Theano/tensorflow를 이용한 상위 레벨의 deep learning library
• Theano/TF