1. TensorFlow - CNN (Convolutional Neural Networks)

  • 개요
    • Fully connected
    • Foward nn
    • split & merge 를 진행하는 NN (CNN 의 기본 원리 - 입력을 여러개로 나누어 받는다.)
  • 고양이 실험
    • 그림을 보여주었을 때 동작되는 뉴런들이 각각 다르다.
    • 입력을 나누어 받는다.

  • Conv, LELU, POOL 등을 여러번 반복한 뒤, FC 를 적용


  • Convolution Layer (32*32*3 형태의 이미지 (RGB))  -> 결과(32*32*filter_depth)
    • 1. 5*5*3 filter 지정 - 여기서 filter 는 w라 하자.
    • 2. 5*5*3 filter는 하나의 값을 가져온다.
      • Wx+b  를 이용하여 한 값으로 만들어낸다.
      • ReLU(Wx+b) 함수를 이용하여 0 이상의 값으로 출력
      • W의 
    • 3. 옆으로 filter (w) 를 옆으로 넘기면서 전체 이미지를 훑는다.
      • 이렇게 하면 28 * 28 의 Activation Map 이 생긴다.
    • 4. 다른 W 값을 준 또 다른 filter 를 만들어서 동일하게 전체 이미지를 훑는다.
    • 5. 6개의 필터를 적용하면,
      • pad 적용을 안할 경우 28*28  이다.
  • W 의 개수?  (5*5*3*depth)

  • pad : activation Map이 input 과 동일한 크기를 유지하기 위해 주는 값
    • 테두리에 0으로된 padding 을 추가해주는 방법
    • 원본 input 데이터에 대한 손실 방지

  • Activation Map 크기 계산 (N - input size , F - filter size)
    • (N - F +(2 x pad size))  / stride

  • Stride : filter 가 이동되는 값의 단위
    • Stride 값이 클수록 output 크기가 작아진다.

  • 예시) 이미지에서 7 * 7 input 일 때 3*3 filter 가 있다면, 한번 훑는 것으로 몇개의 값을 가져올 수 있을까?
    • 한칸씩 움직일 때 (stride = 1)
      • 5*5
    • 두칸씩 움직일 때 (stride = 2)
      • 3*3
    • 공식 (N - input size , F - filter size)
      • (N-F)/stride +1
    • 사이즈가 줄어들었다..


  • 예시) 이미지에서 7 * 7 input 일 때 3*3 filter 가 있다면, 한번 훑는 것으로 몇개의 값을 가져올 수 있을까? (pad 는 1px 이다.)
    • pad 를 감싸게 되면 9*9로 이미지가 변한다.
      • 즉, 결과값은 같은 사이즈의 데이터가 나온다.
    • pad 를 추가하여 이미지 사이즈가 줄어드는 것을 방지.
    • 일반적으로는 output 의 사이즈가 동일하게 맞춰줄 수 있는 pad 값을 준다.

                






  • Pooling layer (Sampling)
    • 작게 resize 한 뒤, 다시 쌓는다.
    • filter 사이즈 내에서 하나의 샘플링 데이터를 추출하는것.
  • MAX POOLING
    • max pool  filter 가 2*2일 때, stride 가 2일때,
    • 가장 큰값을 필터에서 추출.

  • Fully connected 
    • 마지막 결과값은 Softmax 를 사용하여 처리.  (sigmoid)



다양한 활용의 예

  • LeNet-5
    • input 32*32
    • filter 5*5, stride 1
    • subsampling - 2*2, stride 2

  • C1 : Activation Map(28*28) *6 (Convolution 6 filters)
  • S2 : Activation Map(14*14) *6 (subsampling)
  • C3 : Activation Map(10*10) *10 (Convolution 10 filters)
  • S4 : Activation Map(5*5) *16 (subsampling)
  • C5 : 120 (Full connection)
  • F6 : 84 (Full connection)
  • output : 10 (Gaussian connections)

(N-F)/stride +1

  • AlexNet
    • 최초로 ReLU 사용, ensemble 을 이용하여 에러율을 줄임.
    • input 227*227*3 
    • First layer : filter size(11*11*3) *96 filters , stride 4
    • -> (55*55) * 96 filters  (버림)

                





  • ResNet 
    • AlexNet : 8layers,
    • VGG : 19layers,
    • ResNet : 152 layers

    • FastFoward 를 통해서 layer 가 많을수록 학습이 어려운 문제를 해결함.
  • 알파고








CNN
  • 주어진 이미지 벡터에 필터라는 것을 대어서 한개의 값을 뽑는데, 위치를 이동하면서 뽑기 때문에 결국 여러개의 값을 뽑아낸다.
  • 샘플링의 과정을 통해 데이터량을 축소시킨다.
    • 이 두 과정이 CNN


  1. Simple Convolution Layer (예제)
  • 조건
    • 3*3*1 image
    • 2*2*1 filter
    • stride : 1*1
  • Convolution 결과 예측
    • 2*2*1 의 데이터가 추출됨.
    • tensorflow 에서는 값이 알아서 추출되기 때문에 계산할 필요 없음.

  • 이미지를 만들어볼까요?
    • 이미지 생성 코드
sess = tf.InteractiveSession()
image = np.array([[[[1],[2],[3]],
                [[4],[5],[6]]],
                [[7],[8],[9]]]], dtype=np.float32)
print(image.shape)
# 결과값 : (1,3,3,1) - 사용할 이미지는 1개이며, 3*3의 이미지이며 컬러는 1개이다.

# imshow 라는 라이브러리를 사용하여 이미지를 생성한다.
pit.imshow(image.reshape(3,3), cmap='Greys')
  • 만들어진 이미지
                            


  • 이제 W (Filter) 를 정의해보자.
    • Filter 의 shape은 (2,2,1,1) - 2*2 사이즈에 한가지 컬러, 그리고 filter 개수가 1개이다.
    • 값 : [[[1.]],[[1.]]],      - !!!!값은 네개 다 같아야하는지??- 같아야되긴하는데...왜?
                                     [[1.]],[[1.]]]]  - shape = (2,2,1,1)  
                                        


  • 계산하면? (stride 는 1*1 이며 패딩은 없음)
    • 첫번째칸 1*1 + 2*1 + 4*1 + 5*1 = 12
    • 두번째칸 2*1 + 3*1 + 5*1 + 6*1 = 16
    • 세번째칸 4*1 + 5*1 + 7*1 + 8*1 = 24
    • 네번째칸 5*1 + 6*1 + 8*1 + 9*1 = 28
                            


  • 위 계산을 tensorFlow에서는..
# print("imag:\n", image)
print("image.shape", image.shape)
# 결과값 : image.shape (1, 3, 3, 1)

# 가장 depth 가 낮은 것은 필터 개수.
weight = tf.constant([[[[1.]],[[1.]]],
                      [[[1.]],[[1.]]]])
print("weight.shape", weight.shape)
# 결과값 : weight.shape (2, 2, 1, 1)

# tf.nn.conv2d 함수 하나로 Convolution 해결.
conv2d = tf.nn.conv2d(image, weight, strides=[1, 1, 1, 1], padding='VALID')

# tensorflow 실행
conv2d_img = conv2d.eval()

###### 결과값 확인 #######
print("conv2d_img.shape", conv2d_img.shape)
# 결과값 : conv2d_img.shape (1, 2, 2, 1)

#시각화 결과 출력
conv2d_img = np.swapaxes(conv2d_img, 0, 3)
for i, one_img in enumerate(conv2d_img):
    print(one_img.reshape(2,2))
    plt.subplot(1,2,i+1), plt.imshow(one_img.reshape(2,2), cmap='gray')
 
                    
                


  • SAME Padding
    • VALID : padding 을 주지 않는다.
    • SAME : 원래 이미지와 똑같은 shape 를 원할 때 사용.
    • 소스코드
...
# tf.nn.conv2d 함수 하나로 Convolution 해결.
conv2d = tf.nn.conv2d(image, weight, strides=[1, 1, 1, 1], padding='SAME')
...

                


  • 필터를 여러개 쓸 경우.
    • 소스코드

...
# 필터가 3개.
weight = tf.constant([[[[1.,10.,-1.]],[[1.,10.,-1.]]],
                              [[[1.,10.,-1.]],[[1.,10.,-1.]]]])
...

                  




이 장은 이어서...
  • MAX POOLING
    • 소스코드
image = np.array([[[[4],[3]],
                  [[2],[1]]]], dtype=np.float32)
pool = tf.nn.max_pool(image, ksize=[1, 2, 2, 1],
                                   strides=[1, 1, 1, 1], padding='VALID')
print(pool.shape)
# 결과값 (1,1,1,1)
print(pool.eval())
# 결과값 [[[[4.]]]]
                 








출처 : https://docs.google.com/presentation/d/1h90rpyWiVlwkuCtMgTLfAVKIiqJrFunnKR7dqPNtI6I/edit#slide=id.g1ed3f9369e_0_449









  1. TensorFlow - CNN (Convolutional Neural Networks)


  • 딥러닝의 역사
    • http://solarisailab.com/archives/1206
      • 강의 내용에서 보던 내용들도 있지만,
      • Perceptron 이라는 개념이 추가로 들어가 있어서 한번쯤 보면 좋을 것 같음.


  • CNN 개요
    • Fully connected - 
    • Foward nn
    • split & merge nn.. (CNN 의 기본 원리 - 입력을 열개로 나누어 받는다.)
  • 고양이 실험
    • 그림을 보여주었을 때 동작되는 뉴런들이 각각 다르다.
    • 입력을 나누어 받는다.

  • Conv, LELU, POOL 등을 여러번 반복한 뒤, FC 를 적용


  • Convolution Layer (32*32*3 형태의 이미지 (RGB))  -> 결과(32*32*filter_depth)
    • 1. 5*5*3 filter 지정 - 여기서 filter 는 w라 하자.
    • 2. 5*5*3 filter는 하나의 값을 가져온다.
      • Wx+b  를 이용하여 한 값으로 만들어낸다.
      • ReLU(Wx+b) 함수를 이용하여 0 이상의 값으로 출력
      • W의 
    • 3. 옆으로 filter (w) 를 옆으로 넘기면서 전체 이미지를 훑는다.
      • 이렇게 하면 28 * 28 의 Activation Map 이 생긴다.

  • 4. 다른 W 값을 준 또 다른 filter 를 만들어서 동일하게 전체 이미지를 훑는다.
  • 5. 6개의 필터를 적용하면,
    • pad 적용을 안할 경우 28*28  이다.
  • W 의 개수?  (5*5*3*depth)

  • pad : activation Map이 input 과 동일한 크기를 유지하기 위해 주는 값
    • 테두리에 0으로된 padding 을 추가해주는 방법
    • 원본 input 데이터에 대한 손실 방지

  • Activation Map 크기 계산 (N - input size , F - filter size)
    • (N - F +(2 x pad size))  / stride

  • Stride : filter 가 이동되는 값의 단위
    • Stride 값이 클수록 output 크기가 작아진다.

  • 예시) 이미지에서 7 * 7 input 일 때 3*3 filter 가 있다면, 한번 훑는 것으로 몇개의 값을 가져올 수 있을까?
    • 한칸씩 움직일 때 (stride = 1)
      • 5*5
    • 두칸씩 움직일 때 (stride = 2)
      • 3*3
    • 공식 (N - input size , F - filter size)
      • (N-F)/stride +1
    • 사이즈가 줄어들었다..


  • 예시) 이미지에서 7 * 7 input 일 때 3*3 filter 가 있다면, 한번 훑는 것으로 몇개의 값을 가져올 수 있을까? (pad 는 1px 이다.)
    • pad 를 감싸게 되면 9*9로 이미지가 변한다.
      • 즉, 결과값은 같은 사이즈의 데이터가 나온다.
    • pad 를 추가하여 이미지 사이즈가 줄어드는 것을 방지.
    • 일반적으로는 output 의 사이즈가 동일하게 맞춰줄 수 있는 pad 값을 준다.

                






  • Pooling layer (Sampling)
    • 작게 resize 한 뒤, 다시 쌓는다.
    • filter 사이즈 내에서 하나의 샘플링 데이터를 추출하는것.
  • MAX POOLING
    • max pool  filter 가 2*2일 때, stride 가 2일때,
    • 가장 큰값을 필터에서 추출.

  • Fully connected 
    • 마지막 결과값은 Softmax 를 사용하여 처리.  (sigmoid)



다양한 활용의 예

  • LeNet-5
    • input 32*32
    • filter 5*5, stride 1
    • subsampling - 2*2, stride 2

  • C1 : Activation Map(28*28) *6 (Convolution 6 filters)
  • S2 : Activation Map(14*14) *6 (subsampling)
  • C3 : Activation Map(10*10) *10 (Convolution 10 filters)
  • S4 : Activation Map(5*5) *16 (subsampling)
  • C5 : 120 (Full connection)
  • F6 : 84 (Full connection)
  • output : 10 (Gaussian connections)

(N-F)/stride +1

  • AlexNet
    • 최초로 ReLU 사용, ensemble 을 이용하여 에러율을 줄임.
    • input 227*227*3 
    • First layer : filter size(11*11*3) *96 filters , stride 4
    • -> (55*55) * 96 filters  (버림)

                





  • ResNet 
    • AlexNet : 8layers,
    • VGG : 19layers,
    • ResNet : 152 layers

    • FastFoward 를 통해서 layer 가 많을수록 학습이 어려운 문제를 해결함.
  • 알파고








CNN
  • 주어진 이미지 벡터에 필터라는 것을 대어서 한개의 값을 뽑는데, 위치를 이동하면서 뽑기 때문에 결국 여러개의 값을 뽑아낸다.
  • 샘플링의 과정을 통해 데이터량을 축소시킨다.
    • 이 두 과정이 CNN


  1. Simple Convolution Layer (예제)
  • 조건
    • 3*3*1 image
    • 2*2*1 filter
    • stride : 1*1
  • Convolution 결과 예측
    • 2*2*1 의 데이터가 추출됨.
    • tensorflow 에서는 값이 알아서 추출되기 때문에 계산할 필요 없음.

  • 이미지를 만들어볼까요?
    • 이미지 생성 코드
sess = tf.InteractiveSession()
image = np.array([[[[1],[2],[3]],
                [[4],[5],[6]]],
                [[7],[8],[9]]]], dtype=np.float32)
print(image.shape)
# 결과값 : (1,3,3,1) - 사용할 이미지는 1개이며, 3*3의 이미지이며 컬러는 1개이다.

# imshow 라는 라이브러리를 사용하여 이미지를 생성한다.
pit.imshow(image.reshape(3,3), cmap='Greys')
  • 만들어진 이미지
                            


  • 이제 W (Filter) 를 정의해보자.
    • Filter 의 shape은 (2,2,1,1) - 2*2 사이즈에 한가지 컬러, 그리고 filter 개수가 1개이다.
    • 값 : [[[1.]],[[1.]]],      - !!!!값은 네개 다 같아야하는지??
                                     [[1.]],[[1.]]]]  - shape = (2,2,1,1)  
                                        


  • 계산하면? (stride 는 1*1 이며 패딩은 없음)
    • 첫번째칸 1*1 + 2*1 + 4*1 + 5*1 = 12
    • 두번째칸 2*1 + 3*1 + 5*1 + 6*1 = 16
    • 세번째칸 4*1 + 5*1 + 7*1 + 8*1 = 24
    • 네번째칸 5*1 + 6*1 + 8*1 + 9*1 = 28
                            


  • 위 계산을 tensorFlow에서는..
# print("imag:\n", image)
print("image.shape", image.shape)
# 결과값 : image.shape (1, 3, 3, 1)

# 가장 depth 가 낮은 것은 필터 개수.
weight = tf.constant([[[[1.]],[[1.]]],
                      [[[1.]],[[1.]]]])
print("weight.shape", weight.shape)
# 결과값 : weight.shape (2, 2, 1, 1)

# tf.nn.conv2d 함수 하나로 Convolution 해결.
conv2d = tf.nn.conv2d(image, weight, strides=[1, 1, 1, 1], padding='VALID')

# tensorflow 실행
conv2d_img = conv2d.eval()

###### 결과값 확인 #######
print("conv2d_img.shape", conv2d_img.shape)
# 결과값 : conv2d_img.shape (1, 2, 2, 1)

#시각화 결과 출력
conv2d_img = np.swapaxes(conv2d_img, 0, 3)
for i, one_img in enumerate(conv2d_img):
    print(one_img.reshape(2,2))
    plt.subplot(1,2,i+1), plt.imshow(one_img.reshape(2,2), cmap='gray')
 
                    
                


  • SAME Padding
    • VALID : padding 을 주지 않는다.
    • SAME : 원래 이미지와 똑같은 shape 를 원할 때 사용.
    • 소스코드
...
# tf.nn.conv2d 함수 하나로 Convolution 해결.
conv2d = tf.nn.conv2d(image, weight, strides=[1, 1, 1, 1], padding='SAME')
...

                


  • 필터를 여러개 쓸 경우.
    • 소스코드

...
# 필터가 3개.
weight = tf.constant([[[[1.,10.,-1.]],[[1.,10.,-1.]]],
                              [[[1.,10.,-1.]],[[1.,10.,-1.]]]])
...

                  


여기까지...



  • MAX POOLING
    • 소스코드
image = np.array([[[[4],[3]],
                  [[2],[1]]]], dtype=np.float32)
pool = tf.nn.max_pool(image, ksize=[1, 2, 2, 1],
                                   strides=[1, 1, 1, 1], padding='VALID')
print(pool.shape)
# 결과값 (1,1,1,1)
print(pool.eval())
# 결과값 [[[[4.]]]]
                 

















TensorFlow - ReLU



ReLU 소개

  • sigmoid 는 activation function 으로 불린다.
  • 전달받은 값이 어느 값 이상이면 작용을 하는 함수를 activation function 이라 불린다.




  • XOR 를 2단의 NN 으로 구현




  • 3단 이상인 경우



  • 9단


  • 9단 시각화




  • 문제점
    • Backpropagation 은  9단 이상 가면 Accuracy 가 보장되지 못한다.
      • 9단까지 연결했는데도 Accuracy 가 0.5 가 나온다.
      • S 를 거친 output 을 input 으로 가지는 S 는 0~1 의 값을 가진다. 
        • 항상  0~1 사이의 값이 곱해지면서 계산이 진행될 수록 0에 가까워진다.
      • Vanishing gradient 문제 (경사의 기울기가 사라지는 문제)
        • 단수가 깊어질 수록 앞쪽의 경사도가 사라진다.
  • 해결 (Hinton)
    • Sigmoid 가 1보다 작은 값이 된다는 것이 문제.
    • 0보다 작으면 0, 0보다 크면 갈때까지 가면 되지 않을까?
    • ReLU : Rectified Linear Unit

  • NN 에서는 Sigmoid 가 아닌 ReLU 를 사용해야 한다.
    • 마지막에만 sigmoid 사용 (0~1 사이의 값)


  • 파생된 다른 Activiation Function 들.
    • 0 이하의 값도 표현하는 LeakyReLU




     

초기값 주는것

  • weight 에 초기값을 멍청한 값을 줘서 문제가 생겼었다 (Sigmoid)
     




  • 주의점
    • 초기값은 0이 아니여야 한다.
      • 초기값이 0이면 앞의 모든 기울기가 0이됨...
    • RBM 구조를 사용한다.

  • RBM  내용 추가.
  • RBM
    • forward 의  x 값과 backward x 추측 값을 비교하여 w 을 계속하여 조정하는 구조.
    • 다른말로 encode, decode 

  • RBM 으로 어떻게 초기화를 진행할까
    • w 을 모두 학습시킨다. 한스텝씩 foward, backward 를 진행하면서.. 


  • RBM 대신..
                    



               







  • Overfitting 
    • 트레이닝 데이터에 나오지 않은 테스트 데이터에 대한 적중률이 낮음.
    • 레이어가 많아질 수록 err가 떨어지는데, 테스트데이터는 err 가 높아짐.

  • Overfitting 방지
    • 트레이닝 데이터셋 개수를 늘린다.
    • 정규화 : 구불구불한 선을 피자.
    • Dropout
      • 훈련할 때 랜덤한 뉴런을 스킵시킨다.
      • 첫 훈련은 너 쉬어, 두번째 훈련은 너 쉬어.
      • 마지막엔 총 동원하여 예측


  • Dropout 구현
    • 마지막엔 dropout_rate 가 1이여야함. (학습때만 조절.)


  • 앙상블 (Ensemble)
    • 다양한 트레이닝셋과, 학습 모델을 합치는것.






  • Feedforward neural network
    • 가장 일반적으로 쓰이는 네트워크
    • 첫번째 레이어는 input, 마지막 레이어는 output 인 구조이다.
    • 중간의 레이어들을 'hidden' 레이어 라고 부른다.
      • 이 hidden 레이어가 1개 이상일 경우, 'Deep' 뉴런 네트워크라 불린다.
                    

  • Fast forword (less net 이라는 네트워크 구조)
    • 출력을 2단 앞으로 붙인다. (도중의 Activation Function 은 스킵이 된다.)  3% 이하로..
                    

  • Split & Merge
    • 이 네트워크는 
                    




  • Recurrent Network
    • 같은 
               






  • 초기화
    • 구글 - xavier initialization tensorflow 검색

  • Optimizers
    • 어떤것이 더 좋은지는 테스트해보자.


  • 어떤 optimizer가 시뮬레이션한 웹 페이지가 있음.
    • Adam 이 결과가 가장 좋더라..
  • Adam
# define cost/loss & optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
    logits=hypothesis, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

  • 요약
    • Softmax - 90%, NN - 94.5
    • Xivier initialization - 97.8
    • Deep NN + dropout - 98%
    • Adam 등의 optimizer
    • Batch Normalization
      • 입력값에 대한 정규화 방법
      • 이용해서 98% 이상을 뽑아내보자.

  • CNN 을 사용하면 99% 까지 올릴 수 있다.



+ Recent posts