달력

05

« 2018/05 »

  •  
  •  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  •  
  •  

[정리] 모두를 위한 딥러닝 10 - ReLU & 초기값 정하기   by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


시그모이드 결과값은 0<f(x)<1 이기 때문에 이를 체인룰에 따라 계속 곱하다보면 (레이어가 많으면) 

0.01 * 0.03 * 0.2 와 같은 형태가 되기 때문에 결국 한없이 0 에 가까워 진다. 

즉, 입력값 X 가 결과값 f(x), Y 에 미치는 영향이 거의 없게 된다.  

따라서 학습을 깊게 여러번 하면 에러가 커지는 현상이 일어난다. (이건 오버피팅과 다르다)


이를 극복하기 위한 함수가 렐루 ReLU 이다.

렐루는 0 이하는 0 으로, 그 이상값은 자기 자신의 값을 갖는다.


이 두가지 함수를 비교하기 위해 텐서보드 tensorboard 를 이용해보자.

텐서보드로 분석할 수 있도록 로그를 남긴 다음, 텐서보드를 띄워서 웹브라우저로 확인하면 된다.


1번 방법 = 시그모이드로 레이어 10개 사용하기.


2번 방법 = 렐루로 레이어 10개 사용하기.




초기값 잘 설정하기


RBM : Restricted Boatman (Boltzman) Machine

자비어 : xavier

MSRA



Posted by 멋지다마라송

[정리] 모두를 위한 딥러닝 09 - XOR 풀기  by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


XOR 게이트는 한개의 리니어 함수로는 풀 수 없고, 여러개를 이용하면 풀 수 있다.


이렇게 3개로 연결해서 만들면 된다.


여기에서는 w1, b1 값이 주어졌는데, 이 값 말고도 다른 값도 찾을 수 있다.

이 슬라이드에서 주어진 5, -8 / -7, 3 / -11, 6 이런 값을 학습을 통해 찾아야 한다.


이를 위해 백 프로파게이션 기법을 이용한다.

출력으로 나온 에러 loss 를 다시 뒤에서부터 계산하는 방법이다. (편미분 사용)


아래 슬라이드에서 보면 빨간색 가장 위에 글자.

편미분 : w 가 f 에 미치는 영향. 이걸 봐보자. 

결국 입력값이 가장 마지막에 있는 f 에 미치는 영향.이 필요한건데, 아래와 같이 구할 수 있다.

w 가 f 에 미치는 영향 = g 가 f 에 미치는 영향 * x 가 f 에 미치는 영향 = 편미분 f/g * 편미분 g/x  = 1 * w


이렇게 편미분을 뒤에서부터 계산하면 아주 쉽게 이 값들을 구할 수 있다.

편미분들의 곱으로 전체를 나타내는 방법 = 백 프로파게이션 = 체인룰

특히 가장 마지막에 있는 함수 f 를 Activation Function 이라고 부른다.

자, 그런데 이 함수가 시그모이드 형태를 띄고 있다면 문제가 좀 있다.

1 또는 0 에 수렴하기 때문에 무조건 1 보다 작다.

그러니 f 결과값, 즉 액티베이션 함수의 결과값을 곱하면 (이런 로직이 생긴다) 0 보다 한없이 작아진다.

이걸 어째.. 다음번에 이걸 풀어보자.


참고로, 이렇게 그려지는 그래프를 텐서보드로 확인하는 방법 (소스 09-4)

D:\marasong\Workspace\DeepLearningZeroToAll-master>tensorboard --logdir=./logs/xor_logs_r0_01

실행한 다음 웹 브라우저로 확인.

Posted by 멋지다마라송

[정리] 모두를 위한 딥러닝 08 - 딥러닝 개념  by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


사람의 뇌를 연구해보니 작은 뉴런들이 신호를 주고 받는걸로 밝혀졌는데,
이 뉴런 하나하나는 아주 단순한 신호를 전달하지만, 이게 합해지면서 바로 생각이라는게 만들어진다는 것이었다.

이를 기계에도 적용해서 학습시키면 좋은 결과가 나오지 않을까 하는게 바로 CNN 이다.


그리고, 리니어 리그레션만으로는 XOR 를 풀 수 없다.


이런 문제를 Convolutional Neural Networks (CNN) 기법으로 풀 수 있다.


MNIST = 글자 이미지를 분석해서 어떤 글자인지 맞추는 학습인데, 지금은 거의 99% 정확도에 도달했다.




Posted by 멋지다마라송

[정리] 모두를 위한 딥러닝 07 - 실전 연습 및 팁  by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


러닝 레이트 learning rate 가 너무 크면 아래와 같이 예측값이 안드로메다로 간다...


반대로 러닝 레이트 learning rate 가 너무 작으면 좋은 예측을 못하거나 엄청 오래걸린다. 


2차 함수를 3차원처럼 등고선으로 나타낼 수도 있다.

만약 x1, x2 두 값이 입력값인데, 차이가 너무 크다면 납작한 원이 될 수 있다.

이렇게 되면 선처리를 해야 한다.


이렇게 넓은 범위를 포함하고 있는 입력값이 있다면 이를 적절한 범위로 만드는 선처리 작업이 필요하다.

그게 프리 프로세싱. 노말라이제이션. 정규화.


정규화를 위한 많은 알고리즘이 있지만 유명한 스탠다디제이션.

코드를 보니 파이썬에서 구현할때에는 좀 쉬워보인다.


다음에는 오버피팅.

빨간 네모가 예측해야 하는 값이라면 이게 - 마이너스일까 + 플러스일까.

왼쪽 그래프로 본다면 - 마이너스가 되지만 (적절한 학습), 오른쪽 그래프로 보면 + 플러스가 된다.

- 마이너스가 맞는 값인데, 너무 정확하게 학습하면 + 플러스로 잘못 예측하게 된다.

이게 오버피팅이다. 

너무 구부리지 말자.

어떻게?

많은 트레이닝 셋. (데이터가 많아야 한다)

너무 큰 값, 동떨어진 값, 특정값은 줄여야 한다.

일반화를 시켜야 한다.


이를 파이썬으로 구현하면 아주 쉽다.

square 함수를 사용하면 된다.


그래서 트레이닝 세트가 (기반 데이터가) 많으면 일부를 따로 뺀다.

그 데이터는 트레이닝을 하지 않고 모의 테스트를 진행한다.






Posted by 멋지다마라송

[정리] 모두를 위한 딥러닝 06 - Softmax Regression (Multinomial Logistic Regression)  by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


결과값이 A, B, C 중에 하나인 경우, 지금까지 알아본 내용(리니어 리그리션)으로는 불가능하다.

시그모이드 개념과 비슷하긴 하지만, 이 함수만으로는 3개중에 하나로 수렴할 수 있는 방법이 없다.


A, B, C 가 나올 확률을 구해서 가장 높은거 하나만 1, 나머지는 0 으로 만들면 된다.

A, B, C 가 나올 확률의 합은 1 이다. 입력 X, 결과 Y 모두 행렬을 이용한다. 이 개념이 소프트맥스 softmax 이다.

이를 위해 로그함수를 두번 사용하면 가능하며, 더 발전된 원핫 인코딩 One-Hot 함수를 사용하면 좋다.




실제 코딩은 아래와 같다.




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


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())


  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}))


-----------------------------------------------------------------------------

파일에서 불러와서 원핫 인코딩을 사용하는 샘플

# 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]]


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

Y_one_hot = tf.reshape(Y_one_hot, [-1, nb_classes])


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)

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)))



소스코드 : https://github.com/hunkim/DeepLearningZeroToAll



Posted by 멋지다마라송

[정리] 모두를 위한 딥러닝 05 - Logistic Classification  by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


지금까지는 결과값 Y 가 숫자였는데, 이번 강의에서는 0 또는 1 이렇게 둘 중 하나인 경우를 살펴본다.

병에 걸렸는지 여부, 시험을 통화할 수 있는지 여부 등에 이용할 수 있다.


이를 나타내려면 단순히 직선 그래프로는 안되고 0 또는 1 에 수렴해야 하는데, 이때 사용되는 함수는 아래와 같다. 


시그모이드 (하이퍼볼릭 탄젠트 tanh 파란색 점선) 함수로 나타낼 수 있다.



로그 함수로 나타낼 수도 있다.

여기에서 빨간색이 X 축이라면 Y 값은 0 또는 1 에 수렴하는 그래프가 된다. 오 ~ 


이를 파이썬으로 구현하면 아래와 같다.

x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]]

y_data = [[0], [0], [0], [1], [1], [1]]

# placeholders for a tensor that will be always fed.

X = tf.placeholder(tf.float32, shape=[None, 2])

Y = tf.placeholder(tf.float32, shape=[None, 1])


W = tf.Variable(tf.random_normal([2, 1]), name='weight')

b = tf.Variable(tf.random_normal([1]), name='bias')

# Hypothesis using sigmoid: tf.div(1., 1. + tf.exp(tf.matmul(X, W)))

hypothesis = tf.sigmoid(tf.matmul(X, W) + b)

# cost/loss function

cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))

train = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost)


# Accuracy computation

# True if hypothesis>0.5 else False

predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)

accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))


# Launch graph

with tf.Session() as sess:

  # Initialize TensorFlow variables

  sess.run(tf.global_variables_initializer())


  for step in range(10001):

      cost_val, _ = sess.run([cost, train], feed_dict={X: x_data, Y: y_data})

      if step % 200 == 0:

          print(step, cost_val)


  # Accuracy report

  h, c, a = sess.run([hypothesis, predicted, accuracy],

                     feed_dict={X: x_data, Y: y_data})

  print("\nHypothesis: ", h, "\nCorrect (Y): ", c, "\nAccuracy: ", a)



소스코드 : https://github.com/hunkim/DeepLearningZeroToAll


Posted by 멋지다마라송

[정리] 모두를 위한 딥러닝 04 - Multi-Variable Linear Regression by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


x 가 여러개인 경우, 행렬을 이용해서 Y 를 예측하는 방법.


이를 파이썬으로 구현하면 아래와 같다.


import tensorflow as tf

x_data = [[73., 80., 75.], [93., 88., 93.],

        [89., 91., 90.], [96., 98., 100.], [73., 66., 70.]]

y_data = [[152.], [185.], [180.], [196.], [142.]]

# placeholders for a tensor that will be always fed.

X = tf.placeholder(tf.float32, shape=[None, 3]) # [n, 3] 행렬. x_data 세트 = n 개

Y = tf.placeholder(tf.float32, shape=[None, 1]) # [n, 1] 행렬.


W = tf.Variable(tf.random_normal([3, 1]), name='weight')

b = tf.Variable(tf.random_normal([1]), name='bias')


# Hypothesis

hypothesis = tf.matmul(X, W) + b

# Simplified cost/loss function

cost = tf.reduce_mean(tf.square(hypothesis - Y))

# Minimize

optimizer = tf.train.GradientDescentOptimizer(learning_rate=1e-5)

train = optimizer.minimize(cost)


# Launch the graph in a session.

sess = tf.Session()

# Initializes global variables in the graph.

sess.run(tf.global_variables_initializer())


for step in range(2001):

  cost_val, hy_val, _ = sess.run(

      [cost, hypothesis, train], feed_dict={X: x_data, Y: y_data})

  if step % 10 == 0:

      print(step, "Cost: ", cost_val, "\nPrediction:\n", hy_val)


소스코드 : https://github.com/hunkim/DeepLearningZeroToAll

Posted by 멋지다마라송

[정리] 모두를 위한 딥러닝 03 - cost 줄이기 by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


W=2 일때에도 계산해보자.


이걸 2차원 그래프로 나타내면 아래와 같다.

W=1 이 정답이다. (Y = 1 * X)

이를 3차원 그래프로 나타내면 아래와 같다.


W=1 인 값은 미분했을때 (접선의 기울기) 0 이 되는 곳이다.


이걸 파이썬을 이용해서 구현하면 아래와 같다.


초기값을 5 로 주고, 0.1 씩 곡선을 타고 내려가는데 GradientDescentOptimizer 라는 최적화 함수를 이용하면 된다.

오, 6번만에 정답을 찾았다.


다른 예로, 초기값을 -3 으로 주고, 0.1 씩 곡선을 타고 내려간다.

역시 6번만에 정답을 찾았다.


소스코드 : https://github.com/hunkim/DeepLearningZeroToAll

Posted by 멋지다마라송

[정리] 모두를 위한 딥러닝 02 - Linear Regression by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


먼저 가설을 세워야 한다.

우선 그 가설은 직선이다. (리니어 리그레션)

가설 (직선) 과 실제값 (그래프에서 X 로 표시된 값) 의 차이를 줄여야 한다.

가설값과 실제값과의 차이를 코스트 cost 또는 로스 loss 라고 한다.

차이가 양수일수도 있고 음수일수도 있으며, 차이가 크면 클수록 문제가 큰거니까 이 차이 (빨간선의 길이) 를 제곱한다.


이제 이 차이를 줄여야 한다.

코드에서 보면

# Our hypothesis XW+b

hypothesis = X * W + b

# cost/loss function

cost = tf.reduce_mean(tf.square(hypothesis - Y))

# Minimize

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)

train = optimizer.minimize(cost)


이렇게 minimize(cost) 가 있는데, 바로 이게 차이를 최소로 줄인다는 의미이다.

Posted by 멋지다마라송

[정리] 모두를 위한 딥러닝 00~01 by 김성훈 


강의 웹사이트 : http://hunkim.github.io/ml/

Lec = 강의 / Lab = 실습


Lec 00 : 머신러닝, 딥러닝 개요  

유투브 동영상 : https://c11.kr/xuc

인공지능 > 머신러닝 > 딥러닝 

강의 목적 : 머신러닝에 관심이 있는 사람들이라면 누구든 이해하고 개발할 수 있도록 도와주기 위해.

머신러닝 : 특정 입력을 기반으로 원하는 출력을 만드는 것. 

알아서 배울 수 있다면 로직이 정해져있지 않아도 (학습을 할 수 있으면) 원하는 출력을 얻을 수 있다. (오!)


Andrew Ng’s ML class : 앤드류 응 교수님 강의 (추천!)

https://www.coursera.org/learn/machine-learning (코세라 사이트는 프로그래밍 관련해서 좋은 강의가 많다)

- https://class.coursera.org/ml-003/lecture 

- http://www.holehouse.org/mlclass/ (note) 


• Convolutional Neural Networks for Visual Recognition. 

- http://cs231n.github.io/ 


• TensorFlow : 구글에서 만든 머신러닝 라이브러리 오픈소스 

- https://www.tensorflow.org 

- https://github.com/aymericdamien/TensorFlow-Examples



Lec 01 : 기본적인 머신러닝 용어와 개념 설명.

유투브 동영상 : https://c11.kr/xue

Supervised Learning : f레이블이 있는 기반 데이터를 가지고 학습하는 방법. 스팸 필터, 강아지 그림 맞추기 등.

Unsupervised Learning : 레이블이 없는 데이터를 가지고 학습하는 방법. 비슷한 뉴스를 모아라 등.


Types of Supervised Learning 수퍼바이즈드 러닝의 종류

- Regression : 정해진 스코어 (0~100) 중에서 점수를 예측하는 학습.

- Binary Classification : 둘중 하나 (통과/실패처럼) 를 예측하는 학습.

- Multi-Label Classification : A, B, C, D 처럼 등급을 예측하는 학습.


Lab 01 : Tensorflow 텐서플로우 설치, 기본적인 연산

유투브 동영상 : https://c11.kr/xug

왜 텐서플로우인가

https://github.com/thedataincubator/data-science-blogs/blob/master/output/DL_libraries_final_Rankings.csv


설치 : https://c11.kr/xun

기본문법 : https://github.com/sjchoi86/Tensorflow-101/blob/master/notebooks/basic_python.ipynb

기본용어 정리 : https://c11.kr/xup


Posted by 멋지다마라송


티스토리 툴바