[머신러닝]

 > supervised learning   : 정답이 있는 트레이닝 데이터로 트레이닝 하여 label(cat/dog/mug/hat)을 나눔(regression;연속된 값중 답 찾기, classification;pass/nonpass,학점과 같은 개수가 정해진 답 찾기)

 > unsupervised learning : 정답없는 데이터를 받아 어떤 패턴에 따라 데이터를 나눔(google news grouping, clustering)

[머신러닝 프로세스]

 > training data set -> ML algorithm -> (training) -> (model) -> 특정 x input, 미지의 y output

[tensorflow]

 > tensor는 노드를 나타내고 이런 노드의 흐름으로 머신러닝을 하기때문에 이름이 tensorflow 다.

[linear regression]

 > 데이터셋에 맞는 직선(가설)을 찾아 새로운 x를 데입하여 y를 찾는 것.

 > hypothesis(가설) : H(x) = Wx + b (W는 Weight, b는 bias)

 > cost cunftion : cost(W,b) = 1/m * sum( ( H(x(i)) - y(i) )^2 ) -> 이것을 최소로 하는 가설의 W와 b를 찾는다

 > gradient descent algoritm(minimize cost function) : cost function을 그래프로 그려보면 밥 그릇 모양 이므로, 그래프의 특정 위치에서 시작하여 미분으로 기울기를 구하고, 그 기울기를 반영한 값을 현재 위치(W,b)에 적용(빼기)하기를 반복해서 기울기가 0(cost가 가장적은)이 나오는 (W,b)를 찾는다.

 > 우선 단순하게 b를 배제한 W에 대해서만 생각해보면..(W만 있으면 2차원 밥 그릇, b까지 있으면 3차원 밥 그릇 모양)

 > W := W - a * a/aW * cost(W)

 > W := W - a * 1/m * sum( W(x(i)) - y(i) ) * x(i)

 > 식을 보면 W에 cost를 미분한 경사를 빼고 있다. 경사가 - 면 + 방향으로 + 면 - 방향으로 점점 이동한다.

 > a는 얼마만큼의 스텝으로 경사를 내려갈까 하는 learning_rate 라고 한다(동영상을 보면 보통 0.001(softmax), 0.1(그 외) 인듯)

[multi-variable linear regression]

 > 실제 변수(피처)가 하나인 선형회귀는 쓸모가 없다(모든 현상에는 여러가지 변수가 적용하므로)

 > hopothesis

   [b w1 w2 w3] * [ 1  = [b * 1 + w1 * x1 + w2 * x2 + w3 * x3]

                           x1

                           x2

                           x3

                          ]

   => H(X) = WX, 가로 세로가 달라서 싫으니까 W를 세로로만들면 H(X) = W^T * X3

 > cost function 및 minimize cost function algorithm 은 같음

[logistic classification]

 > pass/nonpass 문제는 linear regression 가설로 적당하지 않다(데이터 분포가 두단계로만 나누어져 쭉 나타나기 때문에 최소화 직선을 찾기 어렵다)

   |    1/1 1 1 1 

   |    /

   |   /

   |0 /0 0 

   |--------------

 > linear regression의 값을 0~1사이에 값으로 치환해주는 함수가 필요

 > logistic function or sigmoid function : g(z) = 1 / (1 + e^-z) => 우리 가설을 z에 넣어 새로운 가설을 만들면 linear regression의 가설이 sigmoid 형태로 0~1 사이로 나온다 => H(X) = 1 / (1 + e^-(W^T * X))

 > cost function : linear regression cost function 을 사용하면 울퉁불퉁한 밥 그릇 모양이 되서 사용할 수 없게 된다(e의 영향).

                   따라서 다른 cost function 이 필요

                   c(H(x), y) = -log(H(x))    : y = 1 일 때는 이 식을 사용,

                                  = -log(1-H(x)) : y = 0 일 때는 이 식을 사용

                   그래프로 보면 위 식은 H(x)가 1일 때 cost가 0, 0일 때 cost가 무한대로 증가하고, 아래 식은 그 반대이다.

                   깔끔하게 if 분기를 없애기 위해서

                   c(H(x), y) = -ylog(H(x)) -(1-y)log(1-H(x)) : y에 0 또는 1을 대입해보면 위의 수식과 같아짐(0*를 이용한 방법)

                   최종 cost function : c(W) = -1/m * sum( ylog(H(x) + (1-y)log(1-H(x)) )

 > minimize cost는 linear regression과 동일한 gradient descent algorithm이다. 단, 가설 부분(cost fn 부분)만 교체된다.

[softmax regression(multinomial classification)]

 > binary classification 은 그래프에서 반 나눠서 분류하는 것이고, multinomial classification은 여러번 나누어서 A와 not A, B와 not B, C와 not C 각각에 대해 개별적으로 cost를 구해 어느 것이 선택될 활률이 높은지 확인한다.

 > [ Wa1 Wa2 Wa3      [ X1      [ Wa1X1 + Wa2X2 + Wa3X3      [ Ya

     Wb1 Wb2 Wb3   *     X2   =   Wb1X1 + Wb2X2 + Wb3X3   =   Yb   (각각의 예측 값)

     Wc1 Wc2 Wc3 ]        X3 ]      Wc1X1 + Wc2X2 + Wc3X3 ]       Yc ]

 > WX = Y -> A : 2.0

                     B : 1.0                                                                          

                     C : 0.1                                                                          

(이런식으로 연속된 값이 나오므로, 0~1사이의 값으로 변환 필요;sigmoid) -> 0.7 (3수를 다 더하면 1이다(확률), 따라서 A가 선택된다.)

 > 위에서 sigmoid 해주는 함수가 softmax 함수라고 한다.

 > hypothesis(softmax function) : S(y(i)) = e^y(i) / sum( e^y(i) )

 > cost function(Cross-Entropy) : D(S, L) = -sum( L(i) * log(S(i)) ) = sum( L(i) * -log(S(i)) ) ; S는 예측 값, L은 실제 값

 > 위 cost function에서 -log(S(i)) 값은 logistic 에서 나왔던 예측 값이 1일 때, cost가 0, 예측 값이 0일 때, cost가 무한으로 증가하는 그래프이다.

 > 수식으로 풀어보면..

 > Y = L = [ 0(A)   ,  Y_1 = [ 0(정답)   ,  Y_2 = [ 1(오답)   일 때,

                  1(B) ]                1 ]                       0 ]

 > Y_1의 cost는 => [ 0   * -log[ 0   = [ 0   * [ 무한대 = [ 0   =  0

                              1 ]            1 ]      1 ]         0 ]       0 ]

 > Y_2의 cost는 => [ 0   * -log[ 1   = [ 0   * [ 0        = [ 0         =  무한대

                              1 ]            0 ]      1 ]     무한대 ]     무한대 ]

 > 여기에서 [ ] 안의 값들은 행렬이 아닌 것 같다(곱셈 규칙이 다르고, 동영상에서는 벡터라고 부른다). 각 행이 개별 적으로 인식되는 듯 하다.

 > 전체 cost function = 1/m * sum( D( S(W(xi)+b), L(i) ) )

 > 이 cost function의 그래프도 역시 밥 그릇 모양이므로, minimize에 gradient descent algorithm 사용

[learning rate]

 > gradient descent algoritm 에서 a 값이 learning rate 이다. 이 값은 얼마만큼 간격으로 경사를 오르 내릴 것인가 하는 것이다.

 > 너무 a가 크면 cost 최소지점을 넘어가버리고, 결국엔 그래프 밖으로 나가게 된다. 이를 overshooting 이라 한다.

 > 너무 a가 작으면 cost 최소지점을 찾기전에 traning이 끝나버릴 수 도 있다.

 > 일반적으로 0.01로 시작해보고 작동하는 걸 지켜본후 조절하자.

[data preprocessing]

 > x1, x2 가 있을 때, cost 그래프는 보통 정원형의 3D 밥 그릇 모양이지만, x1과 x2의 값의 차이가 큰 데이터인 경우 옆으로 눌린 모양의 밥 그릇이 된다.

 > 이런경우 learning rate을 잘 잡아도 그래프 밖으로 튈 수 가(overshooting) 있다.

 > 따라서 값 들을 일저아게 변형할 필요가 있는데, 그 방법 중 하나가 normalization(정규화) 이다.

[overfitting]

 > 학습 데이터에 너무 심하게 딱 맞게 모델을 만들어서, 학습 데이터에서는 잘 되지만 실제 데이터가 들어오면 잘 안되는 것을 overfitting 이라 한다.

 > 데이터에 너무 딱 맞게 그래프를 구부려서 나타나는 현상이다.

 > overfitting을 없애는 방법으로는

   1) 트레이닝 데이터를 많이 확보한다.

   2) 중복데이터 등의 피처 개수를 줄인다.

   3) regularization(일반화)를 한다.

 > regularization은 cost 함수에 term을 추가하는 것이다.

 > cost fn = cost fn + r(람다) * sum(W^2)

 > 각 앨리먼트(W)에 제곱을 하여 구부림을 핀다.

 > 람다는 상수이며, 0인 경우 regularization을 안하겠다는 뜻이고, 클 수록 regularization에 비중을 두겠다는 이야기다.

 > 이렇게 cost fn을 재정의 해서 최소 값을 구하면 된다.

[training and test set]

 > training set(교과서)의 몇 %를 빼서 test set(시험)으로 사용한다.

 > 또 training set의 일부를 빼서 validation set(모의고사)로 사용할 수 있다(learning rate(알파), regularization의 강도(람다)를 튜닝하는 목적으로 사용).

 > online learning : 큰 데이터 셋(예, 100만개)을 한번에 학습하지 않고, 작게 나누어(예, 10만개씩) 순차적으로 트레이닝하는 기법으로 cost는 각각 구하는 것이 아니라 각 나온 cost를 m(100만개/10만개=10만개)으로 나눈 누적합을 구하고 그것을 cost로 삼는다.

 > MINIST dataset : 사람 손글씨 데이터

[neural network]

 > 우리 뇌의 뉴런은 어떤 입력(x)을 받아 가중치(w)를 곱하고, 이를 합(sum)한 후 편향(b)을 더해 나온 값이 일정 값(activation function)을 넘으면 다음을 활성화(1), 안넘으면 비활성화(0) 한다.

 >          x0 -> w0 -> x0w0 -> (cell body)                 ->                                -> 1 

   (input) x1 -> w1 -> x1w1 -> sum( w(i) * x(i) ) + b -> (activation function) -> (output)

              x2 -> w2 -> x1w2 ->                                 ->                               -> 0

 > 각 input w(i)x(i)들이 다음의 여러 output에 동시다발적으로 물린다. 이를 그림으로 그리면 우리가 흔히 보는 뉴럴넷의 모습이다.

 > 아래 그래프를 보면 OR, AND는 linear(sum(wx)+b)모델로 풀 수 있지만, XOR는 linear모델로 풀 수 없다. 이 문제 때문에 옛날에 딥러닝이 잠깐 나왔다가 들어갔다. 침체기1

    [OR]         [AND]       [XOR]

  1|1    1     1|0    1    1|1    0

   |            |           |

   |0    1      |0    0     |0    1

   |-------     |-------    |-------

  0      1     0       1   0      1

 > 그 이후로 해결법이 나왔는데,

   - Backpropagation : 잘못된 값이 나왔을 때, 역으로 뉴럴넷을 타고 들어가 w들을 수정한다(피드백).

   - Convolutional Neural Network : 어떤 입력 하나를 여러개의 부분으로 쪼개서 학습시킨다(알파고도 이걸 썼고, 이 알고리즘으로 구글 이전에 자율주행자동차 개발 됐었음).

 > 하지만 또다른 문제가 있는데, 실제문제를 풀려면 굉장히 많은 레이어가 필요한데 Backpropagation으로는 성능이슈가 굉장히 컸다. 침체기2

[deep learning]

 > 앞 부분에서 W를 잘 주면 기존 뉴럴네트워크의 문제를 해결할 수 있다는 논문이 발표(2006년)되고, 많은 발전을 이루었다.

 > 하지만 뉴럴네트워크가 워낙 인기가 없고, 이미지가 안좋아서 deep learning 이라는 새로운 이름을 지어 사람들의 관심을 끌었다.

 > deep api learning : 글로 무엇을 하고 싶은지 쓰면, 그것을 분석해서 무슨 API를 사용하여 프로그래밍하면 될지 알려주는 딥러닝 기법. 

 > 딥러닝으로 할 수 있는 것 또는 하고 있는 것

   1) 무슨 이미지 인지 맞추고, 설명도 가능함

   2) 사람 말을 알아듣고, 그것을 자막으로 만들어줌(유투브 자막)

   3) 게임 AI(알파고 등)

   4) 페이스북, 구글에서 내가 관심있는 것을 보여주는데 사용됨

   5) 넷플릭스, 아마존의 추천 시스템

[xor]

 > XOR 문제는 하나의 뉴런유닛(x-□-y)으로는 풀 수 없었다. 하지만 뉴런유닛 여러 개(2개 이상)를 합치면 풀 수 있다.

 > 그런데 그럼 각 뉴런유닛의 W와 b를 어떻게 학습하냐 하는 문제가 제기됐다(이번 예제에서는 우리가 지정한 W와 b로 하지만, 자동적으로 각 W와 b를 어떻게 구하는가 하는 문제가 남은 것 이다(back propagation으로 품)).

 > 뉴럴 네트워크의 모습(□은 퍼셉트론이고, s는 sigmoid) :

   x1 - □(W=[5 ,b=-8) - s ＼

      ＼      5]             □(W=[-11 ,b=6) - s - y_

      /                            -11]

   x2 - □(W=[-7 ,b=3) - s /

              -7]

 > 위 식으로 아래 x1, x2 를 대입하여 y1, y2, y_ 를 구해보면 xor와 동일 한 것을 알 수 있다.

   x1 x2 | y1 y2 | y_ | xor

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

   0  0  | 0  1  | 0  | 0

   0  1  | 0  0  | 1  | 1

   1  0  | 0  0  | 1  | 1

   1  1  | 1  0  | 0  | 0

   표의 1번항목일 때:

    [0, 0][5, - 8 = 0 - 8 = -8 => y1 = s(-8) = 0 (sigmoid 그래프는 x축 -가 크면 y는 0에 가깝고, x축 +가 크면 y는 1에 가깝다)

             5]

    [0, 0][-7, + 3 = 0 + 3 = 3 => y2 = s(3) = 1

             -7]

    [0, 1][-11 + 6 = -11+6 = -5 => y_ = s(-5) = 0

             -11]

   이렇게 4가지 케이스를 다 구해보면 위 표와 같음

 > 이것은 multinormial 이기 때문에, 하나로 합쳐 정리하면 :

   X - □(W1=[5,-7 , B1=[-8,3]) - s - □(W2=[-11 ,b2=6) - s - y_

                   5,-7]                          (K)       -11]

 > NN의 hypothesis(가설) :

   K(X) = sigmoid( XW1 + B1 )

   Y_ = H(X) = sigmoid( K(X)W2 + b2 )

[미분]

 > 미분은 순간변화율을 나타낸다.

 > 함수 f(x)의 순간변화율은 d/dx * f(x) 이렇게 표현할 수 있다(d/dx가 미분한다는 뜻).

 > d/dx * f(x) = lim(△x->0) * ( ( f(x+△x)-f(x) ) / △x ) => △x가 0에 가깝게 변할 때, f(x)는 얼마만큼 변하는가(f(x)의 순간변화율)

 > 예1) △x가 0.01 일 때, 순간변화율은?

   f(x) =  3 일 때, 3 - 3 / 0.01 = 0

   f(x) =  x 일 때, (f(x+0.01)-f(x)) / 0.01 = (x+0.01-x) / 0.01 = 1

   f(x) = 2x 일 때, ( 2(x+0.01)-2x ) / 0.01 = 2

 > partiol derivative : 내가 관심있는 것만 미분하고, 나머지는 상수로 본다(표현 : ∂f / ∂x (x만 신경쓰겠다))

 > 예2)

   f(x) = 2x 일 때, 2 였음

   f(x,y) = xy,∂f / ∂x 일 때, y

   f(x,y) = xy,∂f / ∂y 일 때, x

 > 예3)

   f(x) = 3 일 때, 0 이었음

   f(x) = 2x = x + x 는 각 항의 미분을 합한다. 따라서, 1 + 1 = 2

   f(x) = x + 3 일 때, 1

   f(x,y) = x+y,∂f / ∂x 일 때, 1

   f(x,y) = x+y,∂f / ∂y 일 때, 1

 > 복합함수의 미분(예, H(X) = sigmoid(Z), Z = WX+b)

   f(g(x))의 미분은 df/dx(x가 f에 미치는 영향)

   df/dx = df/dg * dg/dx

[back propagation(chain rule)]

 > 다음과 같은 식의 뉴런유닛이 있다.

   f = wx + b

   g = wx (미분하면 : ∂g/∂w = x, ∂g/∂x = w)

   f = g + b (미분하면 : ∂f/∂g = 1, ∂f/∂b = 1)

 > 1) x=-2, x=5, b=3 과 같은 값이 주어졌으면 아래와 같은 그래프를 그리고 앞에서 부터 계산해 나간다(forward)

   2) 그 다음 거꾸로 미분해 나가면서 각 W의 영향도를 구한다(backward)

 >

   ∂f/∂w = ∂f/∂g * ∂g/∂w = 1 * x = 5 (미분 값이 5라는 것은 w가 증가하면 f는 그에 5배가 더 증가하다는 뜻, w에 x(5)를 곱했으니까 당연하다)

   w=-2         ∂f/∂g = 1

   -------＼    g=-10

            (*) -----＼

   -------/            (+) --- f=-7

   x=5      b=3 -----/ ∂f/∂b = 1 (미분 값이 1이라는 것은 b와 f의 비율이 거의 1:1이라는 뜻, b가 1증가하면 f도 1증가한다)

   ∂f/∂x = ∂f/∂g * ∂g/∂x = 1 * w = -2

 > 아래 그래프처럼 단계가 많아도 거꾸로 계속 미분을 쌓아가면 된다.

   x (∂f/∂x = ∂f/∂g * ∂f/∂x)  <- <- <-    a (∂f/∂a = 1)         

   -------＼    g(∂f/∂g;거꾸로가다보면알게됨) -----＼

            (*) ---- () ---- () ---- () ---- ()        (+) ---- f (f=a+b)

   -------/     g=x*y                           -----/

   y (∂f/∂y = ∂f/∂g * ∂f/∂y)              b (∂f/∂b = 1)

 > 결과가 잘 안나왔을 때, 이렇게 각 W의 영향을 알아내서 잘 맞게 수정해주면서(피드백) 결과가 잘 나오게 하는 학습시키는 것이다.

 > sigmoid 도 아래와 같이 그래프를 그리고 거꾸로 미분해 가면 된다.

   g(z) = 1 / (1 + e^-z)                 x 

   z ---- (* -1) ---- (exp) ---- (+ 1) ----- (* 1/x^2) ---- g

 > tensor flow 가 우리가 식을주면 그래프로 파싱하는데, 그 이유가 바로 back propagation을 하기 위함이다(여기서 성능이 중요할 듯).

[xor NN 실습]

 > correct_predict : Y와 비교하여 일치하는지 안하는지 true, false의 배열(hypothesis에 0.5를 더하고 버림하여, 0 또는 1의 일관된 배열을 얻어 Y와 비교한다)

 > accuracy(정확도) : correct_predict를 float화 하여(1, 0) 다 더한 후 평균을 구해 확률로 나타냄(reduce mean). 예) 0.5

 > XOR 데이터는 일반적인 logistic regression(binary classification)으로 정확도 0.5 밖에 안나옴

 > 따라서 우리가 위에서 배운 예제의 뉴럴 네트워크로 풀어보면..

   X - □(W1=[5,-7 , B1=[-8,3]) - s - □(W2=[-11 ,b2=6) - s - y_

                   5,-7]                         (L2)      -11]

   L2 = sigmoid( XW1 + B1 )

   H(X) = sigmoid( L2W2 + b2 )

 > 이 가설로 텐서플로우 실행해보면 이제 돌리는데 시간이 좀 걸린다. 정확도는 1.0

 > cost와 최소화는 logistic regression과 동일

 > Wide NN

   X - □ - □(세로로 10개 있다고 가정) - Y_(10개가 Y 하나로 귀결)

  (2개)     □

            □

            ..

   W1 = [w(a1).....w(a10)   (2x10)     B1 => 1x10

             w(b1).....w(b10)]

   W2 = [w1    (10x1)                  b2 => 1개

              ..

            w10]

 > Deep NN

   X - □ -(5개)- □ -(4개)- Y_

  (2개)

   W1 => 2x5, W2 => 5x4, W3 => 4x1

   b1 => 1x5, b2 => 1x4, b3 => 1개

 > Deep NN으로 하면 cost가 상당히 낮아짐

[tensor board]

 > tensor board : 데이터를 비주얼하게 보여주는 tensorflow 내장 툴

[ReLU]

 > NN 에서는 sigmoid 같은 함수를 activation function 이라고 부른다(값에 따라 다음이 활성화, 비활성화 된다(?))

 > 첫 번째 레이어(□)를 Input layer, 마지막 레이어를 Output layer, 중간 레이어들은 Hidden layer 라고 부른다.

   x1 - □ - □ - □ - y_

   x2 -    -    -

 > Hidden layer를 9개나 쌓고 돌려봤더니 정확도가 0.5 밖에 안나온다(지난번 2개보다 못한 결과)

 > back propagation이 많은 레이어에서는 학습이 안되는 문제가 발생

 > back propagation은 chain rule로 ∂f/∂x = ∂f/∂g * ∂g/∂x 와 같이 거꾸로 미분 값을 곱해나가는 방식을 쓰는데, sigmoid는 1보다 작은 값들이고, 0.001과 같이 작은 값도 많이 나오는데 이를 곱하다 보니, 뒤로 갈 수록 아주 작은 수가 되어버린다.

 > 이것은 앞으로 갈 수록 결과에 영향을 미치지 못한다는 것을 의미하고 이는 곧 예측이 불가능 하다는 뜻이다.

 > 이 문제를 vanishing gradient(경사 사라짐) 문제 라고 부르는데, 이 때문에 NN에 2차 위기가 찾아왔고, 힌튼 교수님이 이를 해결하신다.

 > 해결법은, 문제의 원인이 sigmoid 이기 때문에 다른 activcation function을 사용하는데, 그것이 ReLU(Rectified Linear Unit)다.

 > ReLU의 그래프는 0보다 작으면 0으로 꺼버리고, 0보다 크면 x축이 증가하는데로 쭉 linear하게 증가한다.

      |  /

      | /

      |/

  -----------

 > ReLU = MAX(0, x)

 > 마지막 레이어(Output layer)는 sigmoid를 써야한다(결과를 위해 0~1 값이 필요하기 때문에).

 > 그 이후 다양한 activation function 이 나왔다(Leaky ReLU, Maxout, ELU, tanh 등).

[weight 초기화]

 > 같은 코드라도 초기 weight를 랜덤으로 -1~1 사이 값을 주기 때문에 cost 그래프가 달라진다.

 > 초기 W값을 0으로 주면 chain rule 할 때 곱하기 때문에 전부 미분 값이 0이 되어버린다.

 > hinton 교수님이 초기화에 대한 논문을 내셨다. Restricted Boatman Machine(RBM)이라는 방법으로 이 방법을 쓴 딥러닝을 Deep Belief Nets 이라고 한다.

 > RBM : 2단 레이어가 x -> □ -> □ -> y 이렇게 있을 때, forward로 값을 구해놓고(x * w), 이번엔 반대로 x_ <- □ <- □ <- y_ 나온 결과에 w을 곱해서(y_ * w) 나온 값 x_와 x의 차이가 최소가 되도록 w의 초기 값을 잡는다.

 > 여기서 앞으로 가는 것을 encode, 뒤로 가는 것을 decode 라고도 한다.

 > 몇 겹의 레이어가 있을 때, 앞에서 부터 2단계만 따로 이 방법으로 W을 구하고, 그 다음 단계로 2단씩 넘어가며 계속 구하는 방법이다.

 > 이렇게 하는 것을 pre-tranning, 실제로 트레이닝 하는 것은 이미 w이 잘되어있어 쉽게 트레이닝 된다고 해서 fine tuning 이라고도 한다.

 > 하지만 이것은 복잡한데, RBM을 안 쓰고도 잘 되는 방법이 나왔다.

 > xavier initialization : rand(in_count, out_count) / sqrt(in_count)

 > 위에 것을 조금 개량한 더 잘되는 he’s initialization : rand(in_count, out_count) / sqrt(in_count / 2)

 > 한 퍼셉트론의 in, out의 개수에 따라 초기화 하는 방법이다.

[dropout & ensemble]

 > netwrok이 deep 할 수록 overfitting될 가능성이 높다. 이런 overfitting을 제거하는 방법은 지난번에 3가지를 이야기 했었다. 그 중 대표적인 것이 regulariztion 이었다.

 > 또 한가지 방법으로 dropout이 있다. dropout이란, 랜덤하게 일부 뉴런들을 쉬게하고 트레이닝 한 후 실전에서는 모두 투입하는 방법이다.

 > dropout rate는 보통 0.5로 한다고 한다. 예제에서는 0.7(30%는 쉼)로 했다.

 > ensemble(앙상블) : 같은 데이터를 개별 뉴럴넷에서 각각 학습시키고, 그 결과들을 모아 하나의 모델로 합치는 방법이다.

[레고블록 같은 deep learning]

 > feedforward NN : 그냥 쭉 일자로 쌓는 방법

 > fast forward : 중간 결과를 다음 뉴런이 아닌, 더 앞에있는 뉴런으로 보내는 방법

 > split & merge : 나눠서 처리하다가, 모아서 하나로 처리하다가 하는 방법 또는 그 반대 또는 복합

 > recurrent netwrok : 일자가 아닌 옆으로도 붙여서 여러방향으로 연결시키는 방법

 > 결론 : 레고블록 처럼 자유롭게 뉴런들을 구성할 수 있다.

[optimizer]

 > 우리가 지금까지 써온 cost optimizer는 gradient descent 인데, 사실 이것보다 좋은 알고리즘이 많다.

 > 그 중 현재까지 알려진 가장 좋은 알고리즘은 adam(아담) 이다.

[convolutional neural network]

 > 고양이 실험에서 착안 됨 : 고양이 눈이 어떤 그림을 볼 때, 그림의 각 부분을 나누어 뉴런들이 각각 입력을 받음

 > 이런 느낌

   x1 - □ ＼

   x2 - □ - □

   x3 - □ /

 > conv net flow

   conv -> relu -> conv -> pool -> (앞뒤포함 원하는대로 구성) -> pool -> 일반적인 NN(fully connected)

 > 이미지에 filter를 씌워 각 부분을 부분적으로 읽어들이는 방법이다.

 > 이미지 크기(7x7)보다 작은 filter(3x3)를 씌우면 그 부분(3x3)에서 1개의 점을 도출 한다(x1~x5, w1~w5, WX+b => ReLU(WX+b) = Y_)

 > w들은 filter가 가지고 있고, 다야안 w을 가지는 filter 여러장을 적용할 수 도 있다.

 > 이렇게 쭉 필터링하면 몇 개의 점을 가질 수 있는 가?

 > 이미지 width * height * color(3) 이 있을 때, filter(예, 3x3)를 적용하여 한 행에 c = (N - F) / stride + 1 만큼 이동하면서 부분적으로 처리, 따라서 cxc만큼의 점이 나옴.

 > N은 이미지의 길이, F는 filter의 길이, stride는 몇 칸만큼 filter를 이동할 것 인가에 대한 변수

 > 이미지가 점점 작아져서 패딩을 하기도 한다(겉을 특정 값(0 등)으로 감싸 이미지 크기와 동일하게 만듬)

 > W 개수는 filter(5x5x3) 6장이면, 5*5*3*6개 이다.

 > □ 이미지 32x32x3 -> conv/ReLU filter 5x5x3 6개 -> □ 필터링된 이미지 28x28x6 -> conv/ReLU filter 5x5x6 10개 -> □ 필터링된 이미지 24x24x10

[maxpooling]

 > pooling : 각 layer를 resize(sample) 하여 다시 쌓는 것

 > maxpooling : pooling도 filter를 적용하는데, 각 filter에 포함된 값 중 가장 큰 값을 뽑아 샘풀링하는 방법

[여러 NN 구성]

 > Le-Net

 > AlexNet : 첫 딥러닝 이미지 넷 우승

 > GoogLeNet

 > ResNet : 이미지넷 3.6% 에러율, 사람 5%보다 적음

[RNN(Recurrent Neural Network)]

 > sequence data / time series 를 대상으로 하는 NN

 >  y(1) y(2) y(t)         y

    |    |    |      (반복)|

   □-->□-->□   =>   |->□(RNN)

   |    |    |         -- |

   x(1) x(2) x(t)         x

 > □(RNN) 부분 모두 같은 function이고, W도 각각 모두 같기 때문에 위 처럼 반복되는 프로세스로 표현 가능함.

 > h(t) = fw( h(t-1), x(t) ) => (WX) => h(t) = tanh( W(hh)*h(t-1) + W(hx)*x(t) ) , tanh은 sigmoid와 같음 activation function , h(t)는 다음 전달 값

 > 각 결과 값이 몇 개의 벡터가 될 것인지느 W의 사이즈에 따라 결정됨.

 > 예)

   * vocabulary : [h, e, l, o], target : "hello"

   target chars :  e(X)         l(X)         l(O)         o(O)

   output layer : [1.0         [0.5         [0.1         [0.2

                        2.2*         0.3          0.5         -1.5

                       -3.0         -1.0*         1.9*        -0.1

                       4.1]         1.2]        -1.1]         2.2*]

   hidden layer :   ↑           ↑*W(hy)     ↑           ↑

              [0      [0.3         [1.0         [0.1         [-0.3

               0  -> -0.1 ->*W(hh) 0.3->-0.5  ->     0.9

               0]      0.9]         0.1]        -0.3]          0.7]

   input layer  :   ↑       +   ↑*W(hx)    ↑           ↑

                       [1           [0           [0           [0

                        0            1            0            0

                        0            0            1            1

                        0]           0]           0]           0]

   input chars  :  h            e            l            l

 > RNN 활용 : 자연어처리 분야, 번역, 봇, 코딩, 시/소설 작문 등

 > RNN의 사용목적에 따라 다양한 형태의 Net을 구성한다.

 > RNN의 단점을 극복하여 나온 것에는 Long Short Term Memory(LSTM)과 GRU가 있고, 보통 일반 RNN은 사용하지 않고 이것들을 사용한다.