git 으로 처음 프로젝트를 만들다 보니 처음 repository 를 만들때 바이너리 파일들을 몽땅 집어넣고 commit하는 실수를 하고 말았다.

그래서 다시 git rm 으로 debug 폴더를 지우고 다시 commit 을 해보았는데 로컬에서는 지워져도 다시 clone 하면 용량이 수십 MB가 되는 현상이 벌어진다.

이것은 git 안에 history를 모두 갖고 있기때문에 발생하는 현상이다. 이때는 history 를 모두 지워야 한다.

예를들어 나의 repository의 branch가 이렇게 되어있는 경우

        g - k

      / 

a - b - d - f - i - j

            \

              h

f 이전까지의 모든 history를 제거하고 싶다면 일단 f까지만의 depth(여기서는 3)를 포함하는 repository를 가져와야 한다.

$ git clone "address to .git" --depth=3      #f까지의 history 를 포함하는 repository 를 가져온다.

$ git checkout --orphan TEMP_BRANCH   #이 repository를 외톨이가 된 임시 브랜치로 체크아웃 한다.

$ git add -A                                                #현재  repository의 모든 파일을 git로 추가한다.

$ git commit -am "Initial Commit"              #여기부터를 "initial commit"으로 커밋한다.

$ git branch -D master                               #오래된 branch 를 제거한다.

$ git branch -m master                              #임시 브랜치를 master로 만든다.

$ git push -f origin master                         #강제로 Repository를 업데이트한다. (다시 되돌릴 수 없으므로 주의)

이렇게 하면 기존의 history 를 제거하고 다시 시작할 수 있다.

단 이렇게 하면 그 전으로 절대 되돌릴 수 없으므로 주의한다.

이 튜토리얼은 Caffe 와 Python을 사용하여 딥러닝으로 개와 고양이 구분하기[1]   글로부터 이어집니다.

4. 합성곱 신경망(CNN)을 사용하여 개와 고양이 식별자 만들기

이번에는 합성곱 신경망을 사용하여 개와 고양이를 구분하는 방법을 알아봅시다. 이 과제를 위해 Kaggle에 있는 개 대 고양이 대회(Dogs vs. Cats competition)에 있는 데이터셋을 사용할 것입니다. 신경망을 구현하기 위해 Caffe라 불리는 프레임웍 그리고 몇가지 파이썬 코드를 사용합니다.

4.1 개와 고양이 데이터 가져오기

먼저 대회 페이지로부터 2가지의 데이터셋을 다운로드 받아야 합니다. train.zip과 test1.zip 파일이 그것입니다. train.zip파일 안에는 개와 고양이로 라벨링된 이미지들이 있고 신경망을 훈련하는데 사용할 것입니다. test1.zip파일에는 분류되지 않은 개와 고양이 사진들이 섞여있으므로 훈련된 모델을 사용하여 식별해야 합니다. 우리의 예측 모델이 얼마나 잘 작동하는지 확인하기 위해서 Kaggle에 업로드하면 됩니다.

4.2 머신 설정

합성곱 신경망을 훈련시키기 위해서는 매우 강력한 GPU머신이 필요합니다.

이 튜토리얼을 진행하기 위해 사용한 시스템은 다음과 같습니다.

16기가 메모리

CPU: Intel® Core™ i7-4720HQ CPU @ 2.60GHz x 8

GPU: GeForce GTX 980M/PCIe/SSE2 + 3기가 메모리

OS: Ubuntu 16.04

그래픽 드라이버, Caffe 그리고 Opencv 를 설치하는 방법은 이전에 올렸던 Ubuntu 16.04 에 Caffe 설치하기(GPU with CUDA) 를 참조하기 바랍니다.

이제 이 튜토리얼을 수행하기 위해 작성된 코드들을 다운로드 하기 위해 git 명령어로 다운로드를 합니다.

git clone https://github.com/kyuhyong/deep_learning_caffe.git

이 Repsitory는 다음과 같에 세개의 폴더로 구성되어 있습니다.

• caffe_models :  우리가 사용할 Caffe모델이 선언되어 있는 파일이 들어있습니다.

• input: 데이터셋, 평가용 데이터등의 자료들을 담고 있는 폴더입니다. 처음에는 비어있습니다.

• pycode: 데이터 처리, 트레이닝 결과를 수행할 파이썬 코드를 담고있습니다.

4.3 Caffe 둘러보기

Caffe는 버클리 비젼, 학습 센터(Berkeley Vision and Learning Center:BVLC)에서 만든 딥러닝 프레임웍입니다. 이것은 C++로 작성되었으며 파이썬과 매트랩 바인딩을 포함하고 있습니다.

Caffe를 사용하여 합성곱망을 훈련하기 위해서는 다음 4개의 단계를 거칩니다.

• 1단계 - 데이타 준비: 이미지를 정리하고 적절한 포맷으로 저장하여 Caffe에서 사용하기 위한 준비를 합니다. 파이썬 스크립트를 통해 이미지 처리와 저장을 수행할 수 있습니다. Caffe에서 직접 이미지를 읽고 처리하는데 많은 시간이 소요되므로 Image의 요소들을 DB와 같이 만들어주는 LMDB파일을 만들게 됩니다.

• 2단계 - 모델 정의: 이 단계에서는 합성곱 신경망(CNN)에 대한 정의, 파라미터와 설정값들을 포함하는 .prototxt 파일을 사용합니다.

• 3단계 - Solver 정의: Solver는 모델 최적화를 담당합니다.  Solver에 관련된 파라미터들은 역시 .prototxt 파일로 되어있습니다.

• 4단계 - 모델 훈련: 터미널에서 Caffe 명령어를 실행하여 모델을 훈련시킵니다. 모델이 훈련되면 .caffemodel 형식의 훈련된 모델이 생성됩니다.

훈련 단계를 거치면 .caffemodel을 사용하여 처음보는(Unseen) 이미지들에 대한 예측을 수행합니다.

4.4 데이터 준비

다운로드한 train.zip 과 test1.zip 파일을 git으로 다운로드한 repository의 input 폴더에 복사합니다. 복사가 완료되면 다음 명령어를 사용하여 파일을 모두 풉니다.

cd ~/deep_learning_caffe/input/
unzip train.zip
unzip test1.zip
rm *.zip

이제 pycode 폴더로 이동하여 create_train_lmdb.py 를 실행하여 train 과 validation LMDB파일을 생성합니다.

cd ../pycode

python create_train_lmdb.py ~/deep_learning_caffe/input/

create_train_lmdb.py 스크립트는 다음을 수행합니다.

• input/train 폴더에 있는 이미지들을 읽고 모든 이미지에 대한 히스토그램 평준화(Equalization)를 수행합니다. Histogram equalization은 이미지의 Contrast(채도)를 조절하는 기술입니다.

•  모든 이미지들을 227 x 227 사이즈로 변경합니다.
•  훈련 데이터들을 2가지 세트로 나눕니다. 전체의 5/6은 훈련을 위한 데이터로 분류해서 train_lmdb를 만들고 나머지 1/6은 평가를 위한 데이터로 분류하여 validation_lmdb를 만듭니다. 훈련 세트는 모델을 훈련시키는데 사용되고 평가용 세트는 모델의 정확성을 측정하는데 사용됩니다.
•  이렇게 만들어진 2개의 LMDB 데이터베이스를 train_lmdb와 validation_lmdb로 저장하여 각각 훈련과 평가용으로 사용합니다.

아래는 이 코드에서 가장 중요한 부분을 설명합니다.

def transform_img(img, img_width=IMAGE_WIDTH, img_height=IMAGE_HEIGHT):

    #Histogram Equalization
    img[:, :, 0] = cv2.equalizeHist(img[:, :, 0])
    img[:, :, 1] = cv2.equalizeHist(img[:, :, 1])
    img[:, :, 2] = cv2.equalizeHist(img[:, :, 2])

    #Image Resizing
    img = cv2.resize(img, (img_width, img_height), interpolation = cv2.INTER_CUBIC)

    return img

transform_img는 컬러 이미지를 입력받아서 3개 컬러 채널에 대해 히스토그램 평준화(Equalization)를 수행하고 이미지의 사이즈를 변경합니다.

make_datum은 이미지를 받아서 그것의 라벨을 붙여서 이미지와 라벨을 포함하는 Datum 객체로 반환합니다.

def make_datum(img, label):
    #image is numpy.ndarray format. BGR instead of RGB
    return caffe_pb2.Datum(
        channels=3,
        width=IMAGE_WIDTH,
        height=IMAGE_HEIGHT,
        label=label,
        data=np.rollaxis(img, 2).tostring()) 

다음 코드는 훈련 데이터의 5/6을 lmdb에 넣는 과정입니다.

 
with in_db.begin(write=True) as in_txn:
    for in_idx, img_path in enumerate(train_data):
	if in_idx % 6 == 0:		# 5/6 of train data used for train
		continue
	img = cv2.imread(img_path, cv2.IMREAD_COLOR)
	img = transform_img(img, img_width=IMAGE_WIDTH, img_height=IMAGE_HEIGHT)
	if 'cat' in img_path:
	    label = 0
	else:
	    label = 1
	datum = make_datum(img, label)
	in_txn.put('{:0>5d}'.format(in_idx), datum.SerializeToString())
	print '{:d} of {:d}|'.format(in_idx,dataNum) + os.path.basename(os.path.dirname(img_path)) + "/"+ os.path.basename(img_path) + ' as {:d}'.format(label),"          \r",
in_db.close()

훈련 데이터의 평균값 이미지(Mean image)생성하기

아래 명령어를 사용하여 훈련 데이터의 평균값 이미지를 생성합니다. 모든 특징점 픽셀들이 평균 제로(zero mean)을 보장하기 위해 각각의 입력 이미지로부터 평균값 이미지를 빼게 됩니다. 이 과정은 Supervised 머신러닝에서 공통적으로 적용되는 전처리 단계입니다.

cd ~/caffe/build/tools
./compute_image_mean -backend=lmdb ~/deep_learning_caffe/input/train_lmdb/ ~/deep_learning_caffe/input/mean.binaryproto

4.4 모델 정의

합성곱(CNN) 신경망을 사용하기로 결정하였으므로 확장자가 .prototxt 인 train_val 파일에 파라미터들을 정의해야합니다. Caffe는 Alexnet 혹은 Googlenet 과 같은 유명한 합성곱 신경망들을 제공합니다. 이 튜토리얼에서는 Alexnet을 살짝 변경한 blvc_reference_caffenet 을 사용할 것입니다. 

git으로 Repsitory를 클론하였다면 caffe_models/caffe_model_1/caffenet_train_val_1.prototxt 파일을 열면 됩니다..

그리고 다음 몇가지 파라미터들을 수정합니다.

•  13, 24, 40 51번째 줄에서 myhome을 여러분의 홈 디렉토리로 변경합니다.
•  우리가 만들 신경망은 개 또는 고양이 2개만을 구분하므로 신경망의 Output은 2개 입니다. 373번째 줄에서 num_output 을 2로 변경합니다.

caffe는 이렇게 정의된 신경망의 구조를 보다 이해하기 쉽게 도표화할 수 있는 파이썬 스크립트 도구를 제공합니다.

python ~/caffe/python/draw_net.py ~/deep_learning_caffe/caffe_models/caffe_model_1/caffenet_train_val_1.prototxt ~/deep_learning_caffe/caffe_models/caffe_model_1/caffe_model_1.png

 위 스크립트를 실행하면 모델의 구조가 caffe_models/caffe_model_1/caffe_model_1.png 이라는 파일로 만들어지게 됩니다.

4.5 Solver 정의

솔버는 모델 최적화를 담당합니다. 솔버의 파라미터들은 .prototxt 파일에 정의되어 있는데 이 파일은 deep_learning_caffe/caffe_models/caffe_model_1/solver_1.prototxt

에 존재합니다.

이 솔버는 모델의 정확성을 매 1,000 iteration마다 계산하게 됩니다. 최적화 과정은 최대 40,000회의 iteration을 수행하면서 매 5,000 iteration 마다 스냅샷을 저장하게 됩니다.(주, iteration을 많이 할수록 정확성이 증가하지만 연산 시간이 증가하게 되므로 적절한 횟수로 제한하는 것이 좋다. 사양이 낮다면 10,000회 정도로도 만족할만한 결과를 얻을 수 있다.)

base_lr, lr_policy, gamma, momentum 그리고  weight_decay등의 파라미터들이 모델의 수렴성을 개선하는 중요한 요소들입니다.

lr_policy는 "step", stepsize가 2500, base_lr가 0.001 그리고 gamma: 0.1로 설정하였습니다.

이렇게 설정하면 학습 속도를 0.001로 시작하여 매 2500 iteration 마다 10배씩 증가시키게 됩니다.

그리고 1번, 13번 줄의 파일 경로에서 /myhome 역시 각자의 홈 디렉토리로 설정합니다.

최적화 과정에는 다른 전략을 선택할 수 있습니다. 더 자세한 사항을 알고싶다면 다음 항목 solver documentation을 찾아보기 바랍니다.

4.6 모델 훈련

모델과 솔버에 대한 정의가 완료되면 이제 caffe 에서 제공하는 train 명령을 통해 훈련을 시작하게 됩니다.

cd ~/caffe/build/tools
./caffe train --solver ~/deep_learning_caffe/caffe_models/caffe_model_1/solver_1.prototxt 2>&1 | tee ~/deep_learning_caffe/caffe_models/caffe_model_1/model_1_train.log

이제 caffe는 데이터를 분석하면서 모델을 훈련시킵니다. 훈련에 걸리는 시간은 컴퓨터 사양과 max iteration 값에 따라 달라집니다. 

터미널 창을 보면서 매 5000 iteration 마다 accuracy 와 loss를 주시합니다. 그리고 이때 snap shot들을 caffe_model_1 폴더에 caffe_model_1_iter_10000.caffemodel. 같은 이름으로 저장하게 됩니다.

학습 곡선 그리기

학습 곡선은 매 iteration마다 훈련과 테스트 손실(Loss)율을 그래프로 나타낸 것입니다. 

이 그래프는 훈련/평가 손실과, 정확성을 시각화하는데 매우 유용합니다.

해당 파이썬 스크립트는 pycode 폴더에 plot_learning_curve.py 라는 파일을 실행하면 됩니다.

python ~/deep_learning_caffe/pycode/plot_learning_curve.py ~/deep_learning_caffe/caffe_models/caffe_model_1/model_1_train.log ~/deep_learning_caffe/caffe_models/caffe_model_1/caffe_model_1_learning_curve.png

4.7 새로운 데이터에 대한 예측

이제 훈련된 모델이 생겼으므로 처음보는 데이터(test1.zip에 포함된 이미지들)에 대해서 예측을 수행할 수 있습니다. 이것은 pycode 폴더에 있는 make_predictions_1.py 스크립트를 수행하면 됩니다. 이 코드를 실행하기 위해서는 4개의 파일이 필요합니다.

1.  test 이미지 파일.

2. mean image : 4.4절에서 만든 평균값 이미지.

3. 모델 아키텍쳐 파일: train과정에서 만들어진 caffenet_deploy_1.prototxt 라는 파일을 사용합니다. 이 파일은 caffenet_train_val_1.prototxt 파일과 거의 유사하지만 몇가지가 변경되어 있습니다. 우리는 여기에서 data_layer 를 지우고 input 레이어를 추가한 다음 마지막 레이어의 형식을 SoftmaxWithLoss 에서 Softmax로 변경합니다.

4. 훈련된 모델 가중치: 이것은 training 단계에서 생성된 파일입니다. 우리는 caffe_model_1_iter_10000.caffemodel을 사용할 것입니다.

원래 스크립트에서는 위 파일들이 하드코딩 되어 있으나 일부 내용을 변경하여 make_predictions_1.py에 대한 입력 인자로 다음의 세가지를 넣도록 변경하였습니다.

 1. input 폴더의 경로

 2. caffe 모델의 경로

 3. test 파일이 있는 폴더의 경로

python ~/deep_learning_caffe/pycode/make_predictions_1.py ~/deep_learning_caffe/input/ ~/deep_learning_caffe/caffe_models/caffe_model_1/ ~/deep_learning_caffe/input/test1/

아래는 코드에서 중요한 부분을 발췌한 것입니다.

먼저 평균값 이미지(mean image)를 mean_array에 배열 형식으로 전달고 caffe 모델의 caffenet_deploy_1.prototxt 파일과, 모델 트레이닝으로 생성된 모델파일인 caffe_model_1_iter_10000.caffemodel 파일을 caffe의 Net에 전달합니다.

#Read mean image
with open(meanBinary) as f:
    mean_blob.ParseFromString(f.read())
mean_array = np.asarray(mean_blob.data, dtype=np.float32).reshape(
    (mean_blob.channels, mean_blob.height, mean_blob.width))
...
#Read model architecture and trained model's weights
net = caffe.Net(caffeProto,
                caffeModel,
                caffe.TEST)

#Define image transformers
transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})
transformer.set_mean('data', mean_array)
transformer.set_transpose('data', (2,0,1))

다음은 새로운 이미지를 읽고 이미지를 모델의 입력에 맞게 처리한 다음 모델을 통과시켜 어떤 확률이 나오는지에 따라 분류하여 (0에 가까우면 고양이, 1에 가까우면 개) 저장합니다.

   
img = cv2.imread(img_path, cv2.IMREAD_COLOR)
    img = transform_img(img, img_width=IMAGE_WIDTH, img_height=IMAGE_HEIGHT)
    
    net.blobs['data'].data[...] = transformer.preprocess('data', img)
    out = net.forward()
    pred_probas = out['prob']

    test_ids = test_ids + [img_path.split('/')[-1][:-4]]
    preds = preds + [pred_probas.argmax()]
    argmax = pred_probas.argmax()
    if argmax == 1:
        shutil.copy2(img_path, dir1path)
    else:
        shutil.copy2(img_path, dir2path)

그리고 판별한 결과를 .cvs 파일에 저장하게 됩니다.

위 스크립트를 실행하게 되면 test폴더에 있는 이미지들이 클래스에 따라 분류되어 각각 predict폴더 안에 c1, c2폴더로 복사되어있음을 확인할 수 있습니다.

분류가 완료된 이미지 파일

2018/1/18에 최초 문서 발행됨

2018/1/22 일부 수정됨

개인적으로 딥러닝을 공부하기 위해 여러가지 책과 논문들 그리고 강의 동영상들을 읽어보았지만 실제로 어떻게 하는가에 많은 의문이 들었던게 사실이다.

인터넷에 있는 예제를 그냥 돌려보는 것은 결과만을 보여줄 뿐 그 과정을 따라가기가 여렵고 특히 데이터 셋을 만드는 방법등은 잘 나와있지 않다. 그래서 어떻게 하면  CNN같은 딥러닝을 구현해볼까 하다가 

다음 사이트를 발견하였다. 

http://adilmoujahid.com/posts/2016/06/introduction-deep-learning-python-caffe/

Adil Moujahid라는 분이 작성한 블로그 포스트로 Caffe에 정의된 다양한 모델을 가지고 여러가지 개와 고양이 사진을 구분하는 과정을 자세히 설명하고 있다.

이 포스트는 원저자의 허락을 받고 일부 코드와 내용을 수정하여 올린것임을 밝힌다.

This post is originated from above article with slight modifications and my own translation under Adil Moujahid's kind permission.

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

이 글의 목적은 딥러닝을 실제로 수행하는 방법을 알려주기 위해 작성되었습니다. 이를 위해서 우리는 개와 고양이 이미지를 Convolutional Neural Network(CNN)이라 불리는 딥러닝 알고리즘을 가지고 클래시파이어(식별자)를 만들 것입니다.

이 글은 2개의 파트로 구성되어 있습니다. 첫번째는 딥러닝에 관한 핵심적인 컨셉 그리고 나머지는 실제 과정을 설명합니다.

실제 과정의 첫번째(4장)에서는 CNN을 처음부터 개발하여 개와 고양이 이미지 식별자를 만들 것입니다. 이를 위해서 약간의 파이썬 코드와 오픈소스 딥러닝 프레임웍으로 널리 사용되는 Caffe를 사용하여 식별자를 만듭니다. 우리의 식별자는 최대 97%의 정확도를 가지게 됩니다.

이 글을 다 읽으면 Convolutional Neural Network이 어떻게 동작하는지를 이해하고 코드를 작성하는 방법에 익숙해질 것입니다.

이 과정의 모든 소스코드 원본은 Github에서 다운로드 받을 수 있습니다.

1. 문제 정의

이 장에서 우리는 Kaggle의 데이터셋을 사용하게 됩니다. 이 데이터셋은 약 25,000장의 개와 고양이 이미지를 포함하고 있습니다.

우리의 목표는 개와 고양이를 구분하는 적절한 머신러닝 알고리즘을 만들어서 이전에 보지 못한 이미지를 식별하는 것입니다.

머신 러닝에서는 이러한 종류의 문제를 식별 문제(Classification)라고 부릅니다.

Kaggle 데이터셋에서 가져온 개와 고양이 샘플

2. 전통적인 머신러닝 대 딥러닝 식별 문제(Classification)

머신러닝 알고리즘을 통한 식별의 2단계:

 - 훈련(Train) 단계: 이미지와 각각의 라벨로 구성된 데이터셋을 사용하여 머신러닝 알고리즘을 훈련시킵니다.

 - 예측(Predict) 단계: 훈련된 모델을 사용하여 처음 보는 이미지에 적용할 라벨을 예측합니다.

이미지 식별 문제를 위한 훈련 단계는 2단계를 거칩니다:

 1. 특징점 추출: 이 단계는 도메인 지식(역자 주, 어떤 물체는 엣지가 많고 다른 물체는 둥그스름한게 많다라는 등의 지식)을 활용하여 머신러닝 알고리즘에서 사용할 특징점들을 찾아냅니다. HoG 와 SIFT는 이러한 영상 식별의 한 예 입니다.

 2. 모델 훈련(Model Training): 이 단계에서는 이미지의 특징점에서 만든 깨끗한 데이터 셋(역자 주, 가장 전형적이라 생각되는 어떤 대표 이미지 예를 들어 누구라도 개 또는 고양이임을 알 수 있는 사진 혹은 그림)을 활용하여 각각의 라벨을 붙여서 머신러닝 모델을 훈련합니다.

예측 단계에서는 동일한 특징점 추출 과정을 적용하여 새로운 이미지를 처리하고 이 특징점을 훈련된 머신러닝 알고리즘에 넣어서(Pass) 라벨을 예측합니다.

머신러닝의 단계

전통적인 머신러닝 기법과 딥러닝 알고리즘의 가장 큰 차이점은 특징점을 찾는 과정입니다. 전통적인 머신러닝 알고리즘은 우리가 각각의 특징점들을 직접 만들어야만 합니다. 반대로 딥러닝 알고리즘에서는 알고리즘 스스로 그러한 특징점을 찾아갑니다. 특징점 추출은 어렵고 시간을 잡아먹으며 특히 도메인 지식이 많이 필요합니다. 딥러닝의 가장 큰 장점은 머신러닝에 비해 특징점을 찾는데 기울이는 노력이 적거나 거의 없게 된다는 점입니다.

3. 딥러닝의 핵심

 딥러닝은 여러 처리 레이어를 포함하는 인공 신경망(Artificial Neural Network)의 클래스를 의미합니다. ANN의 개념은 수십년간 존재해왔지만 2000년대 중반 Geoffrey Hinton이 뚫기 전까지 ANN 구조를 깊게 훈련하는(Training Deep)시도는 번번히 실패해왔습니다. 알고리즘적인 혁신 뿐만 아니라 GPU 성능의 급격한 발전, 그리고 엄청나게 큰 데이터들이 쌓이면서 딥러닝은 급격한 발전을 이룩합니다.

3.1 인공 신경망(ANNs)

인공 신경망(ANNs)은 새포생물학적인 신경망으로부터 착안한 머신 러닝의 조합입니다.

인공신경망 대 생물 신경망

생물학적 신경은 인간의 뇌를 구성하는 가장 핵심적인 부분입니다. 하나의 신경은 1개의 새포, 수상돌기(Dentrites) 그리고 축색돌기(Axon)로 이루어져있습니다.

신경 세포가 처리한 정보는 전기신호를 통해 다른 신경에 전달됩니다. 각각의 신경은 수상돌기를 통해 신호를 입력받고 다시 축색돌기로 출력합니다. 축색돌기는 시냅스를 통해 연결된 다른 새포의 수상돌기로 뻩어나갑니다.

신경이 작동하는 가장 단순한 모델은 다음과 같습니다: 각각의 시냅스는 학습이 가능한 강도를 가지고 있고 그것의 강도를 조절하여 신경간의 영향을 제어합니다. 수상돌기는 그것의 총합이 목표 신경의 몸체에 전달할 신호를 가지고 있습니다. 만약 최종 합이 어떤 임계값을 넘는다면 신경은 활성화되고 축색돌기를 통해 자극을 전달합니다. [1]

인공 신경은 생물학적 신경으로부터 영감을 얻어 위에 서술한 모델을 컴퓨터화된 방식으로 구체화하였습니다. 하나의 인공 신경은 각각 특정한 정도(Weight)를 가진 유한한 숫자의 입력과 하나의 활성화 함수(전달함수라 불리기도 하는)로 구성되어 있습니다. 신경의 출력은 결국 이러한 입력의 총합이 이 활성화 함수를 거쳐서 나온 결과입니다. 인공 신경은 서로 연결되어 있어서 인공 신경망을 구성합니다.

Feedforward 신경망

피드포워드 신경망은 인공 신경망의 가장 간단한 구조입니다.

이 네트워크에는 3가지 종류의 레이어가 있습니다: 입력 레이어(단), 은닉(Hidden) 단 그리고 출력단 입니다. 이 네트워크 안에서 데이터는 입력단으로부터 들어가서 은닉단을 거쳐 출력 노드로 나갑니다.

아래는 완전 연결된 2개의 은닉단을 포함하는 피드포워드 신경망을 나타내고 있습니다. "완전 연결"이라는 말은 각각의 노드들이 다음 노드들과 모두 연결되어 있음을 의미합니다.

은닉단의 갯수와 그것의 크기만이 유일한 독립(변경되는) 변수입니다. 이론적으로 은닉단이 크고 깊을수록 더욱 복잡한 패턴을 모델링할 수 있다고 알려져 있습니다.

활성화 함수

활성화 함수는 입력의 가중합(Weighted sum)을 인공 신경에 전달하는 역할을 합니다. 이러한 함수는 데이터의 복잡한 패턴을 수치화하기 위해 비선형 함수여야 합니다. 가장 널리 사용되는 활성화 함수는 Sigmoid, Tanh 그리고 ReLU입니다. 그중에서 ReLU는 딥러닝 신경망에서 가장 많이 사용됩니다.

인공 신경망 훈련하기

훈련 단계의 목표는 망의 가중치를 학습하는 것입니다. 우리는 인공 신경망을 훈련하기 위해 2개의 요소가 필요합니다:

 - 훈련 데이터(Training data): 이미지 식별에 있어서 훈련 데이터는 여러 이미지들과 각 이미지에 해당하는 라벨을 포함합니다.

 - 손실 함수(Loss function): 예측한 값의 부정확한 정도를 측정하는 함수

위에 언급한 두가지 요소만 있으면 우리는 역전파(Backpropagation)와 경사하강법(Gradient descent)이라 불리는 알고리즘을 사용하여 인공신경망(ANN)을 훈련하게 됩니다. 역전파에 대해 자세히 알고 싶다면 다음을 참조하기 바랍니다.

3.2 합성곱 신경망(Convolutional Neural Networks) (CNN 혹은 ConvNets)

 합성곱 신경망은 특수한 형태의 Feed-forward 망입니다. 이 모델은 시신경이 동작하는 방식을 모사하기 위해 만들어졌습니다. CNN은 영상 인식에 매우 잘 동작합니다. CNN은 신경망으로 하여금 특정한 영상의 특징을 수치화할 수 있도록 하는 합성곱 레이어와 풀링(Pooling)레이어를 가지고 있습니다.

합성곱 레이어

이 레이어는 필터의 엔트리와 입력 이미지를 dot product 한 계산을 통해 이미지를 구조적으로 잘라낼 수 있는 학습 가능한 여러개의 필터로 구성되어 있습니다. 필터는 입력 이미지의 최대 깊이만큼 확장되어야 합니다. 예를들어 크기가 32x32인 칼라 이미지에 크기가 5x5인 필터를 적용하고자 한다면 3개의 컬러 채널(적색, 녹색, 청색)을 커버하기 위해서 이 필터의 깊이는 반드시 3이 되어야 합니다.(5x5x3) 이러한 필터는 이미지에서 유사한 구조를 발견할 때 활성화 될 것입니다.

풀링 레이어

풀링이란 비선형 다운 샘플링(Down sampling)의 형태를 취합니다. 풀링 단의 목표는 이미지의 공간적 크기를 점진적으로 줄여서 신경망의 변수, 연산 량을 줄여서 오버 피팅을 제어할 수 있도록 하는 것입니다. 풀링을 구성하는 것에는 여러가지 함수가 있지만 맥스풀링(Max pooling)이 가장 널리 사용됩니다. 풀링은 보통 stride가 2인 2x2크기의 필터를 각 깊이에 적용하게 됩니다. 크기가 2x2이고 stride가 2인 풀링단은 입력 영상을 원래 크기의 1/4로 줄입니다.[2]

합성곱 신경망 아키텍쳐

합성곱 신경망의 가장 기본적인 구조는 입력단(이미지)으로부터 시작하여 일련의 합성곱 레이어와 풀링 레이어로 이어지고 완전 연결된 레이어로 끝납니다. 합성곱 레이어는 보통 한개의 ReLU 활성함수 순서로 되어있습니다.

합성곱, 풀링 그리고 ReLU 레이어는 학습 가능한 특징점 추출기 역할을 하고 완전 연결된 레이어는 하나의 머신러닝 식별자 역할을 한다. 특히 신경망의 초기 단계는 이미지의 일반적인 패턴을 수치화 하고 후반에서는 이미지의 세부적인 디테일을 수치화합니다. 

합성곱 레이어와 완전 연결된 레이어에서만 가중치(Weights)가 있음을 유의하세요. 이 가중치들은 훈련 단계에서 학습됩니다.

합성곱 신경망 아키텍쳐의 한 예.

다음은 실제로 합성곱 신경망을 만들어서 개와 고양이를 구분하는 식별자를 만드는 과정으로 이어집니다.

 >> 다음: Caffe 와 Python을 사용하여 딥러닝으로 개와 고양이 구분하기[2]

References

1. CS231n - Neural Networks Part 1: Setting up the Architecture
2. Wikipedia - Convolutional Neural Network