우리는 캐글 동물 데이터를 바탕으로 Multi-Class Classification 를 실습한다.

모델 구현을 위해 다섯 단계를 진행한다.

🌑 데이터셋 다운로드 🌓 이미지와 레이블 불러오기 🌕 전처리와 데이터 분할 🌗 모델 생성과 학습 🌑 신규 이미지 예측

💾 데이터셋

• animal image dataset <링크>

  • panda
  • cat
  • dog

🥕 환경

• python 3.7
• tensorflow 2.6
• keras 2.6
• colab

📁 프로젝트

├── animals
│   ├── panda [1,000 entries]
│   ├── dogs  [1,000 entries]
│   └── cats  [1,000 entries]
├── images
│   ├── panda.jpg
│   ├── dog.jpg
│   └── cat.jpg
└── model.ipynb

🌑 데이터셋 다운로드

링크를 통해 동물 이미지 데이터셋을 다운받는다.

압축을 풀어주면 animals/ 그리고 images/ 폴더를 볼 수 있다.

• animals/ 폴더는 훈련 데이터셋 images/ 는 테스트셋을 의미한다.

또한 우리의 목적은 <panda, dogs, cats> 중 하나의 클래스로 예측하는 것이며

각각의 이미지에 대한 클래스는 상위 폴더 이름이 될 것이다.

마지막으로 📁 프로젝트를 참고하여 디렉토리를 구성하자.

❝ 이제 소스를 작성할 준비가 끝났다. ❞

model.ipynb 에 차근히 코딩을 해보자.

🌓 이미지와 레이블 불러오기

먼저 animals/ 디렉토리 내 전체 이미지 개수를 확인해보자.

❝ 여러가지 방법이 있겠지만 손쉬운 방법이 있다. ❞

imutils.paths.list_images() 사용하면 된다.

이미지 3,000 장 존재하면 성공이다.

이제 파일 경로를 image_paths 변수에 담아보자.

from imutils import paths

search_dir = "animals"

image_paths = sorted(
    list(paths.list_images(search_dir))
)

print(">>> image count =", len(image_paths))

>>> image count = 3000

image_paths 에 담긴 각각의 이미지 경로 하나씩 불러온다.

그리고 이미지는 images 에 저장하고 레이블은 labels 변수에 담는다.

❝ 각각의 이미지에 대한 레이블은 어디 있을까 ? ❞

❝ 폴더 이름을 잘라내어 레이블로 만든다. ❞

이해를 돕기 위해 이미지와 레이블 파트로 나뉘어 설명한다.

우선 실제 이미지 경로를 하나씩 꺼내어

해당 경로 이미지를 cv2.imread() 통해 불러온다.

그리고 cv2.resize() 로 크기를 균일하게 변경한다.

❝ 이미지 크기가 각기 다르기 때문이다. ❞

마지막으로 이를 images 리스트에 순차적으로 담아준다.

레이블 생성도 마찬가지로 이미지 경로가 필요하다.

print(image_path)

>>> data/animals/panda/panda_01000.jpg

우리가 필요한 부분은 panda/ 이며 .split() 으로 잘라주면 된다.

또한 os.path.sep 를 이용하면 구분자를 손쉽게 찾아낼 수 있으므로

뒤에서 두번째 위치 [-2] 를 찾아낸다.

마지막으로 labels 에 저장한다.

import os
import cv2
from tqdm import tqdm

image_dim = (180, 180, 3)

images = []
labels = []
for image_path in tqdm(image_paths):
    image = cv2.imread(image_path)

    image = cv2.resize(
        image, (image_dim[1], image_dim[0])
    )
    images.append(image)

    label = image_path.split(os.path.sep)[-2]
    labels.append([label])

    print(">>> images count =", len(images))

100%|██████████| 3000/3000 [10:44<00:00,  4.65it/s]
>>> images count = 3000

🌕 전처리와 데이터 분할

전처리는 두가지 작업을 할 예정이다.

첫째로 이미지 값을 0 에서 1 사이의 값으로 변환한다.

❝ 그렇다. 스케일링 작업이다. ❞

둘째는 One-Hot Encoding 작업이다.

현재 레이블은 panda, dogs 또는 cats 이다.

❝ 컴퓨터가 읽을 수 있는 형태로 바꿔주자. ❞

sklearn.preprocessing.MultiLabelBinarizer() 사용하여 원핫 인코딩을 할 수 있다.

import numpy as np
from sklearn.preprocessing import MultiLabelBinarizer

images = np.array(images, dtype='float32') / 255.0
labels = np.array(labels)

mlb = MultiLabelBinarizer()
enc_labels = mlb.fit_transform(labels)

print(">>> classes name =", mlb.classes_)

>>> classes name = ['cats' 'dogs' 'panda']

이제 데이터를 분할해보자.

sklearn.model_selection.train_test_split() 으로 데이터 분할을 한다.

Train 데이터 80% 그리고 Test 데이터 20% 를 사용하고자 한다.

from sklearn.model_selection import train_test_split

seed = 47

(x_train, x_test, y_train, y_test) = train_test_split(
    images, enc_labels, test_size=0.2, random_state=seed
)
print(">> train test shape = {} {}".format(
    x_train.shape, y_train.shape)
)

🌗 모델 생성과 학습

모델은 VGGNet 을 참고하여 컨볼루션 크기와 네트워크 깊이를 조절하였다.

여기서 주의할 점은 마지막 출력을 Soft-Max 로 한다는 점이다.

• tensorflow.keras.layers.Activation('softmax')

기억해두자.

Multi-Class Classification 의 마지막 출력은 Soft-Max 이다.

❝ 출력을 Soft-Max 로 안하는 코드도 있던데 ? ❞

구현 방법에 차이로 틀린 건 아니다.

그러나 Binary, Multi-Class, Multi-Label 모두

마지막 출력 함수가 다르기에 하나의 포맷을 추천한다.

위 물음은 하단 모델 컴파일 부분에서 설명하겠다.

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, BatchNormalization
from tensorflow.keras.layers import Activation, Flatten, Dropout, Dense

class Classifier:
    def build(width, height, depth, classes):
        model = Sequential()
        input_shape = (height, width, depth)

        model.add(Conv2D(32, (3, 3), padding='same', input_shape=input_shape))
        model.add(Activation('relu'))
        model.add(BatchNormalization(axis=-1))
        model.add(MaxPooling2D(pool_size=(3, 3)))
        model.add(Dropout(0.25))

        model.add(Conv2D(64, (3, 3), padding='same'))
        model.add(Activation('relu'))
        model.add(BatchNormalization(axis=-1))
        model.add(Conv2D(64, (3, 3), padding='same'))
        model.add(Activation('relu'))
        model.add(BatchNormalization(axis=-1))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Dropout(0.25))

        model.add(Conv2D(128, (3, 3), padding='same'))
        model.add(Activation('relu'))
        model.add(BatchNormalization(axis=-1))
        model.add(Conv2D(128, (3, 3), padding='same'))
        model.add(Activation('relu'))
        model.add(BatchNormalization(axis=-1))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Dropout(0.25))

        model.add(Conv2D(256, (3, 3), padding='same'))
        model.add(Activation('relu'))
        model.add(BatchNormalization(axis=-1))
        model.add(Conv2D(256, (3, 3), padding='same'))
        model.add(Activation('relu'))
        model.add(BatchNormalization(axis=-1))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Dropout(0.25))

        model.add(Flatten())
        model.add(Dense(2048))
        model.add(Activation('relu'))
        model.add(BatchNormalization())
        model.add(Dropout(0.5))

        model.add(Dense(classes))
        model.add(Activation('softmax'))
        return model

model = Classifier.build(
    width=image_dim[1], height=image_dim[0], depth=image_dim[2],
    classes=len(mlb.classes_)
)

이제 모델을 컴파일 해보자.

optimizer 에 tensorflow.keras.optimizers 을 사용하면

학습률 등을 디테일하게 조절할 수 있다.

이제 Loss Function 에 대해 이야기 해보자.

위에서 마지막 출력을 Soft-Max 로 안하는 경우도 있다고 했다.

그런 경우에는 CategoricalCrossentropy(from_logits=True) 으로 변경하면 된다.

그럼 Cross-Entropy 를 계산함에 있어 다르게 동작한다고 한다.

❝ 결과의 차이는 없어보인다. ❞

다만 Tensorflow 공식 홈페이지에서는

from_logits=True 방식이 Numerical stable 하다고 한다.

from tensorflow.keras.losses import CategoricalCrossentropy
from tensorflow.keras.optimizers import Adam

batch_size = 32
epoch = 200
learning_rate = 1e-3
decay = learning_rate / epoch

optimizer = Adam(
    learning_rate=learning_rate,
    decay=decay
)

loss = CategoricalCrossentropy(from_logits=False)

model.compile(
    loss=loss,
    optimizer=optimizer,
    metrics=['accuracy']
)

❝ 이제 거의 다 왔다. 힘내자. ❞

우리는 작은 이미지로 학습을 시키려한다.

따라서 데이터를 증강시키도록 한다.

Kera 에 ImageDataGenerator() 함수를 이용하도록 하자.

• 회전과 위치 변경 등으로 이미지 복제

from tensorflow.keras.preprocessing.image import ImageDataGenerator

aug = ImageDataGenerator(
    rotation_range=25, width_shift_range=0.1, height_shift_range=0.1, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest'
)

❝ 드디어 모델 학습 과정이다. ❞

이 과정에서 GPU 를 사용했다.

그리고 .fit_generator() 으로 데이터를 증강하여 학습시킨다.

history = model.fit_generator(
    aug.flow(
        x_train, y_train, batch_size=batch_size
    ),
    validation_data=(x_test, y_test),
    steps_per_epoch=len(x_train) // batch_size,
    epochs=epoch, verbose=1
)

Epoch 1/200
75/75 [==============================] - 40s 113ms/step - loss: 1.5247 - accuracy: 0.5562 - val_loss: 3.1929 - val_accuracy: 0.3150
Epoch 2/200
75/75 [==============================] - 8s 102ms/step - loss: 0.9905 - accuracy: 0.6021 - val_loss: 1.8746 - val_accuracy: 0.3500
Epoch 3/200
75/75 [==============================] - 8s 102ms/step - loss: 0.9192 - accuracy: 0.6221 - val_loss: 3.2068 - val_accuracy: 0.3500
Epoch 4/200
75/75 [==============================] - 8s 102ms/step - loss: 0.8743 - accuracy: 0.6292 - val_loss: 1.3691 - val_accuracy: 0.3967
Epoch 5/200
75/75 [==============================] - 8s 102ms/step - loss: 0.7978 - accuracy: 0.6508 - val_loss: 1.2389 - val_accuracy: 0.4250
Epoch 6/200
75/75 [==============================] - 8s 102ms/step - loss: 0.7651 - accuracy: 0.6629 - val_loss: 2.1172 - val_accuracy: 0.4283
Epoch 7/200
75/75 [==============================] - 8s 103ms/step - loss: 0.7412 - accuracy: 0.6696 - val_loss: 0.7568 - val_accuracy: 0.6783
...................................................................................................................................
Epoch 197/200
75/75 [==============================] - 8s 105ms/step - loss: 0.0873 - accuracy: 0.9725 - val_loss: 0.6421 - val_accuracy: 0.8567
Epoch 198/200
75/75 [==============================] - 8s 106ms/step - loss: 0.0817 - accuracy: 0.9708 - val_loss: 0.6350 - val_accuracy: 0.8217
Epoch 199/200
75/75 [==============================] - 8s 108ms/step - loss: 0.0875 - accuracy: 0.9712 - val_loss: 0.5505 - val_accuracy: 0.8600
Epoch 200/200
75/75 [==============================] - 8s 108ms/step - loss: 0.0623 - accuracy: 0.9779 - val_loss: 0.4870 - val_accuracy: 0.8850

우리 모델의 Loss 와 Accuracy 를 눈으로 확인해보자.

🌑 신규 이미지 예측

동일한 방법으로 images/ 디렉토리의 파일 경로를 읽는다.

test_image_paths = sorted(
    list(
        paths.list_images("images/")
    )
)
print(">>> test image path =", test_image_paths)

>>> test image path = ['images/cat.jpg', 'images/dog.jpg', 'images/panda.jpg']

이미지와 예측 레이블을 각각 출력해보자.

print(">>> class index =",  mlb.classes_)

for image_path in test_image_paths:
    test_image = cv2.imread(image_path)

    test_image = cv2.resize(
        test_image, (96, 96)
    )
    cv2_imshow(test_image)

    test_image = test_image.astype("float") / 255.0
    test_image = np.expand_dims(test_image, axis=0)

    proba = model.predict(test_image)[0]
    print(
        np.round(proba, 3)
    )
    idx = np.argmax(proba)
    print(">>> predict class =", mlb.classes_[idx])

>>> class index = ['cats' 'dogs' 'panda']

[0.091 0.875 0.034]
>>> predict class = dogs

[0.001 0.999 0.   ]
>>> predict class = dogs

[0.      0.     1.]
>>> predict class = panda

오늘 우리는 Multi-Class Classification 을 코드로 살펴보았다.

이제 그만 알아보자.

다음 포스트에서는 Multi-Label Classification 을 알아보자.

🍀 참고

• VGGNET Architecture
• Multi-Class Clasification with Animals

본격적인 분류 모델 이해에 앞서 Classification 종류에 대해 알아보자.

이 글은 모델 설계에 도움이 될 것이다.

• Binary Classification
• Multi-Class Classification
• Multi-Label Classification

😃 분류 모델의 이해

우리는 목적에 따라 분류 모델을 설계해야 한다.

분류 모델은 크게 세가지로 나뉜다.

• Binary Classification

• Multi-Class Classification

• Multi-Label Classification

위 모델들 구현시에 통계적 이론에 차이가 존재한다.

즉 우리는 목적에 맞는 Classification 을 찾고

그에 알맞은 이론을 구현해야 할 것이다.

더불어 이 글에서는 이미지 분류 모델을 중심으로 설명할 예정이지만

분류 문제는 이미지 분야에 한정되어 있는 건 아니다.

❝ 캐글의 타이타닉 생존자 예측 대회에 대해 들어본 적이 있는가 ? ❞

이는 둘 중 하나로 예측하는 이진 분류 Binary Classification 를 다룬다.

이를 통해 우리는 알 수 있다.

❝ Binary / Multi-Class / Multi-Label 분류는 머신러닝에서도 사용될 수 있는 개념이다. ❞

이제 각각 모델의 Use-Case 를 살펴보도록 하자.

⭐ Binary Classification

❝ 고양이와 강아지 사진을 분류할 수 있을까 ? ❞

우리는 위 물음에 Yes 라고 말할 수 있다.

왜냐하면 두가지 중 하나로 예측하기 위한 모델이 존재하기 때문이다.

Binary Classification 은 예측 범위 Class 가 두가지인 경우에 사용된다.

그렇다면 우리가 수집한 훈련 데이터셋의 Class 도 반드시 2 개여야 한다.

훈련 데이터셋 = {
    이미지 1 : '고양이',
    이미지 2 : '강아지',
    이미지 3 : '강아지',
}

우리는 <고양이, 강아지> 훈련 데이터셋으로 모델을 학습시켰다.

그리고 호랑이 이미지를 넣어 예측을 해보자.

❝ 어떤 결과가 나올까 ? ❞

우리는 ❝ 호랑이야. ❞ 라고 예측을 하거나

❝ 고양이와 강아지가 아니다. ❞ 로 예측하길 바랄 것이다.

아쉽게도 <고양이 또는 강아지> 중 하나로 예측을 한다.

무조건 둘 중에 하나로 예측을 한다.

❝ 그럼 왜 사용하는 거야 ? ❞

우리 주변에는 생각보다 둘 중에 하나인 경우가 많다.

아래 예시를 보자 :

• 적격 - 부적격
• 합격 - 불합격
• 스팸 - 햄
• 고양이 - 고양이가 아닌 것

❝ 그래서 특별히 이진 분류가 있다. ❞

그치만 <고양이, 강아지, 호랑이> 중 하나로 분류를 하고 싶다면

Multi-Class Classification 모델을 구현해야 한다.

⚡ Multi-Class Classification

❝ 고양이, 강아지, 호랑이 중에 하나로 분류를 하고 싶다. ❞

또는

❝ 고양이, 강아지, 호랑이, 사자, 돼지 중에 하나로 분류를 하고 싶다. ❞

첫번째는 3 개의 Class 로 둘째는 5 개의 Class 로 분류하고 싶은 경우이다.

즉 Multi-Class Classification 는 분류하고자 하는 Class 가 3 개 이상인 경우에 사용한다.

❝ Multi-Class 분류에서 데이터셋은 어떻게 구성해야 할까 ? ❞

만약 <강아지, 고양이, 호랑이> 분류 모델을 만들고 싶다면

훈련 데이터셋 = {
    이미지 1 : '고양이',
    이미지 2 : '강아지',
    이미지 3 : '호랑이',
    이미지 4 : '고양이',
    이미지 5 : '강아지',
    이미지 6 : '호랑이'
}

<강아지, 고양이, 호랑이> 사진을 1:1:1 로 수집하면 되고

<강아지, 고양이, 호랑이> 에 대해서는 틀림없이 좋은 성능을 낼 것이다.

그러나 문득 이런 생각이 든다.

❝ 한장의 사진에 고양이와 강아지가 같이 있다면 ? ❞

이런 질문은 대답하기가 쉽지 않다.

❝ 둘 중 하나로 나오지 않을까 ? ❞

이 때 우리는 Multi-Label Classification 을 하면 된다.

🌞 Multi-Label Classification

Multi-Class 와 Multi-Label 은 이름도 비슷하다.

❝ 굳이 모델을 나눈 이유가 있을까? ❞

우리는 다음과 같은 애매한 상황에 처할 수 있다.

❝ 한장의 사진에 고양이와 강아지가 있다. ❞

그리고 <고양이와 강아지> 2 개로 예측하고 싶다.

이때 Multi-Label Classification 을 이용하면 된다.

다시 말해 Multi-Class 에서는 한장의 사진은 무조건 하나의 Class 로 예측되고

Multi-Class 는 두가지 이상의 Class 로 예측될 수 있다.

다만 <고양이와 강아지> 를 예측하기 위해서는

기존의 <고양이, 강아지, 호랑이> 훈련 데이터셋에

<고양이와 강아지> 사진을 합쳐서

Multi-Label Classification 에 학습시켜야 한다.

다음 포스트에서 Classification 설계 방법을 차근히 알아보도록 하자.

• 레이어 개념을 비교 설명하며 활용에 대해 이야기한다.
  • Max Pooling 과 Average Pooling
  • Flatten 과 Global Pooling

😊 레이어 개념 비교 설명

우리는 앞서 이미지 분류를 위한 기본적인 레이어에 대해 살펴보았다.

여기서 우리는 더 깊은 이해를 위해 자료를 찾을 것이고

폴링 Pool Layer 에는 적어도 두가지 존재하는 것을 알게 된다.

❝ Max Pooling 과 Average Pooling 을 볼 수 있다. ❞

여기서 찾아보면

❝ Global Average Pooling 을 볼 수 있을 거다. ❞

같은 레이어 Layer 지만 개념과 목적이 다른

다소 혼란스러운 개념에 대해 이야기 해보고자 한다.

🔨 Max Pooling vs Average Pooling

먼저 폴링 Pooling Layer 의 목적은 최적화 파라미터 개수를 줄이기 위함이다.

그러나 우리는 목적에 따라 폴링을 두가지 형태로 구현할 수 있다.

• Max Pooling

• Average Pooling

최대값 Max 을 활용하면 가장 두드러지는 특징을 찾을 수 있다고 했다.

❝ 그렇다. 최대값이라는 개념을 활용한다면 특징을 잘 찾아낼 수 있다. ❞

반대로 평균 Average 은 덜 중요한 요소를 포함할 수 있다.

❝ 그럼에도 왜 사용하는 것일까 ? 왜냐하면 분산을 사용할 수 있기 때문이다. ❞

평균과 분산 개념을 활용하여 물체 위치를 보다 쉽게 파악할 수 있기 때문이다.

따라서 우리는 객체 탐지 Object Detection 분야에서 Average Pooling 을 효과적으로 활용할 수 있다.

🔧 Flatten vs Global Pooling

Flatten 은 다차원 데이터를 1 차원 데이터로 변경하는 역할을 한다고 했다.

❝ 그렇다면 Global Pooling 과 Flatten 어떤 연관성이 있을까 ? ❞

우선 Global Pooling 은 Pooling 과 달리 사진 한장을 하나의 숫자로 출력할 수 있다.

따라서 Flatten 의 출력과 Global Pooling 출력은 비슷하다.

다만 Max 또는 Average 개념을 포함시킬 수 있으며 출력 길이가 다른 특징이 있다.

또한 Global Average Pooling 은 이미지 설명에도 활용되며

Flatten 에 비해 성능이 좋다고 알려져있다.

한줄로 정리하자면

❝ Global Average Pooling 과 Flatten 은 같은 일을 하며 GAP 를 적용하면 성능 향상을 기대할 수 있다. ❞

이제 우리는 해당 개념에 대해 간단히 알아보았다.

추후 포스트에서 구현과 함께 보다 자세히 알아보도록 하자.

다음 포스트에서는 본격적으로 이미지 분류를 살펴볼 것이다.

• 기본 레이어 개념을 이해하고 구현해본다.
  • 컨볼루션 Conv Layer
  • 플래튼 Flatten Layer
  • 폴링 Pooling Layer

🥕 환경

• 파이썬 3.7
• 텐서플로우 2.6
• 케라스 2.6

😐 기본 레이어 이해

우리는 앞서 딥러닝과 뉴럴 네트워크의 차이를 알아보았다.

그리고 뉴럴 네트워크 구현 최소 단위인 레이어 Layer 가 필요하다고 했다.

여기서는 Conv Layer Pooling Layer Flatten Layer 를 다뤄보도록 하겠다.

❝ 해당 개념은 링크의 동영상을 보는 것을 추천한다. ❞

🏅 Conv Layer <링크>

우리가 이미지 분류를 잘하려면 특징 Feautre 을 잘 파악해야 할 것이다.

❝ 뉴럴 네트워크에서 이미지 특징을 어떻게 뽑아낼 수 있을까 ? ❞

그에 대한 대답으로

❝ Conv Layer 의 필터를 사용하면 된다. ❞

컨볼루션망 CNN, Convolutional Neural Network 을 들어본 경험이 있다면

이미지 분류를 잘하는 모델로 기억할 것이다.

❝ 그렇다. 이미지를 잘 분류하려면 Conv Layer 가 필요하다. ❞

컨볼루션 Conv Layer 에는 필터 Filter 와 커널 Kernel 개념이 존재한다.

❝ 필터란 몇개의 특징으로 출력을 만들어 낼 것인가 ? 를 의미한다. ❞

즉 해당 이미지를 판단하기 위해 가장 좋은 특징맵 Feature Map N 개를 찾아낸다.

또한 특징맵을 한개를 만들어가는 과정에서 커널 Kernel 개념이 사용된다.

이미지 크기가 5 by 5 이고 커널 크기가 3 또는 (3, 3) 인 그림을 살펴보자.

고정된 커널 크기에 따라 곱셈 연산을 하고 이를 모두 더한값을 기록한다.

이제 tf.keras.layers.Conv2D() 이용하여 3 = (3, 3) 커널로 이루어진 32 개의 필터를 만들어보자.

import tensorflow as tf

input_layer = tf.keras.layers.Input(
    shape=(200, 200, 3), name='input_layer'
)

conv_layer = tf.keras.layers.Conv2D(
    filters=32, kernel_size=(3, 3), activation='relu', name='conv_layer'
)(input_layer)

output_layer = tf.keras.layers.Dense(
    units=2, activation='softmax', name='output_layer'
)(conv_layer)

model = tf.keras.models.Model(input_layer, output_layer)

model.summary()

_________________________________________________________________
Layer (type)               Output Shape                  Param # 
=================================================================
input_layer (InputLayer)   [(None, 200, 200, 3)]               0 
_________________________________________________________________
conv_layer (Conv2D)        (None, 198, 198, 32)              896 
_________________________________________________________________
output_layer (Dense)       (None, 198, 198, 2)                66
=================================================================
Total params: 962                                                
Trainable params: 962                                            
Non-trainable params: 0                                          
_________________________________________________________________

그리고 다음과 같은 특징맵 Feature Map 을 얻을 수 있을 것이다.

여기서 특징맵은 200 - (3 - 1) by 200 - (3 - 1) 의 크기로 32 개가 출력된다.

한장의 사진은 (1, 200, 200, 3) 크기로 컨볼루션에 입력되어 (32, 198, 198, 3) 크기로 출력된다.

🥈 Flatten Layer <링크>

먼저 플래튼 Flatten 의 사전적 의미는 다음과 같다.

flatten [ˈflætn]

1. (동사) 납작 [반반] 해지다, 납작하게 [반반하게] 만들다 옥스퍼드 영한사전

플래튼을 사용하는 이유는 단순하다.

우리는 <강아지, 고양이> 이미지 분류 Classification 를 할 예정이라면

1 차원 배열로 출력해야 한다. <두개 값으로 나와야 한다.>

❝ 이미지 1 의 예측값 예시 = [ 강아지 확률, 고양이 확률 ] = [ 90 % , 10 % ] ❞

그러나 우리는 3 차원 이상 배열 Tensor 을 이용해 특징을 찾아가고 있다.

그러므로 플래튼이 없다면 3 차원으로 출력이 될 것이다.

다음 그림의 출력 Output Shape 을 살펴보자.

_________________________________________________________________
Layer (type)               Output Shape                  Param # 
=================================================================
input_layer (InputLayer)   [(None, 200, 200, 3)]               0 
_________________________________________________________________
conv_layer (Conv2D)        (None, 198, 198, 32)              896 
_________________________________________________________________
output_layer (Dense)       (None, 198, 198, 2)                66 
=================================================================

자 이제 텐서플로우 tf.keras.layers.Flatten() 을 통해 일자로 평평하게 만들어보자.

단순 1 차원 배열 Array 로 만드는 것이므로 파라미터는 필요 없다.

import tensorflow as tf

input_layer = tf.keras.layers.Input(
    shape=(200, 200, 3), name='input_layer'
)

conv_layer = tf.keras.layers.Conv2D(
    filters=32, kernel_size=(3, 3), activation='relu', name='conv_layer'
)(input_layer)

faltten_layer = tf.keras.layers.Flatten(name='flatten_layer')(conv_layer)

output_layer = tf.keras.layers.Dense(
    units=2, activation='softmax', name='output_layer'
)(faltten_layer)

model = tf.keras.models.Model(input_layer, output_layer)

model.summary()

_________________________________________________________________
Layer (type)               Output Shape                  Param # 
=================================================================
input_layer (InputLayer)   [(None, 200, 200, 3)]               0 
_________________________________________________________________
flatten_layer (Flatten)    (None, 1254528)                     0 
_________________________________________________________________
conv_layer (Conv2D)        (None, 198, 198, 32)              896 
_________________________________________________________________
output_layer (Dense)       (None, 2)                     2509058 
=================================================================
Total params: 2,509,954                                          
Trainable params: 2,509,954                                      
Non-trainable params: 0                                          
_________________________________________________________________

즉 플래튼을 적용하면 정상적으로 <강아지, 고양이> = [0.9, 0.1] 또는

<강아지, 고양이, 호랑이> = [0.9, 0.0, 0.1] 출력이 가능하다.

🥉 Pooling Layer <링크>

마지막으로 살펴볼 레이어는 풀링 Pooling Layer 이다.

풀링은 Sub Sampling 으로 불리며 이미지 데이터를 작은 크기로 줄여주는 역할을 한다.

풀링에는 대표적으로 Max Pooling Layer 와 Average Pooling Layer 있다.

다음 그림은 Max Pooling Layer 을 나타내며 풀링 크기 Pooling Size 가 (2, 2) 이다.

Max Pooling 풀링 크기에 마춰 해당 픽셀 중 가장 큰 값을 기록한다.

❝ 다시 말해 Max Pooling 을 사용하면 가장 두드러진 특징만을 기록할 수 있다. ❞

❝ 그렇다면 Average Pooling 의 특징은 무엇일까 ? 고민해보고 이포스트 하단을 읽어보자. ❞

그리고 문득 아래와 같은 질문을 할 수 있다.

❝ 이미지 데이터를 작은 크기로 만들 필요가 있을까 ? 왜 그래야만 하는거지 ? ❞

우리는 컨볼루션 Conv Layer 를 바탕으로 이미지 특징을 찾아내고

플래튼 Flatten Layer 으로 일자로 만든 뒤에 확률 형태로 출력을 하였다.

풀링이 없는 뉴럴 네트워크를 구성해도 되지만

최적화 해야되는 파라미터 Parameter 개수가 많아질 것이다.

❝ 파라미터가 많다는 의미 오버피팅, 학습시간 등 문제를 야기한다는 뜻이다. ❞

만약 풀링 Pooling 이 없다면

아래 그림과 같이 2,509,954 개의 파라미터를 찾아야 된다.

_________________________________________________________________
Layer (type)               Output Shape                  Param # 
=================================================================
input_layer (InputLayer)   [(None, 200, 200, 3)]               0 
_________________________________________________________________
conv_layer (Conv2D)        (None, 198, 198, 32)              896 
_________________________________________________________________
flatten_layer (Flatten)    (None, 1254528)                     0 
_________________________________________________________________
output_layer (Dense)       (None, 2)                     2509058 
=================================================================
Total params: 2,509,954                                          
Trainable params: 2,509,954                                      
Non-trainable params: 0                                          
_________________________________________________________________

그래서 우리는 파라미터를 줄이기 위해 Pooling 을 한다.

그리고 Pooling Layer 는 conv_layer 다음에 위치하는 것이 일반적이다.

특징을 찾은 이후에 풀링으로 이미지 크기를 줄인다.

이제 tf.keras.layers.MaxPool2D() 를 바탕으로 Pooling Layer 를 구현해보자.

import tensorflow as tf

input_layer = tf.keras.layers.Input(
    shape=(200, 200, 3), name='input_layer'
)

conv_layer = tf.keras.layers.Conv2D(
    filters=32, kernel_size=(3, 3), activation='relu', name='conv_layer'
)(input_layer)

pool_layer = tf.keras.layers.MaxPool2D(
    pool_size=(3, 3), name='pool_layer'
)(conv_layer)

faltten_layer = tf.keras.layers.Flatten(name='flatten_layer')(pool_layer)

output_layer = tf.keras.layers.Dense(
    units=2, activation='softmax', name='output_layer'
)(faltten_layer)

model = tf.keras.models.Model(input_layer, output_layer)

model.summary()

_________________________________________________________________
Layer (type)               Output Shape                  Param # 
=================================================================
input_layer (InputLayer)   [(None, 200, 200, 3)]               0 
_________________________________________________________________
conv_layer (Conv2D)        (None, 198, 198, 32)              896 
_________________________________________________________________
pool_layer (MaxPooling2D)  (None, 66, 66, 32)                  0 
_________________________________________________________________
flatten_layer (Flatten)    (None, 139392)                      0 
_________________________________________________________________
output_layer (Dense)       (None, 2)                      278786 
=================================================================
Total params: 279,682                                            
Trainable params: 279,682                                        
Non-trainable params: 0                                          
_________________________________________________________________

위 결과와 같이 풀링 Pooling Layer 를 적용하면

279,682 개 파라미터를 최적화 시키면 된다.

만약 풀링이 없다면 2,509,954 파라미터를 찾아야 될 것이다.

추가로 FC 레이어 Fully Connected Layer 에 대해 알아보자.

❝ FC 레이어는 일렬로 펴진 층과 모든 노드가 연결된 구간을 이야기한다. ❞

지금 우리가 만든 모델에도 FC 레이어가 존재한다.

일자로 평평하게 만든 플래튼 Flatten Layer 과 마지막 출력을 위한 Dense Layer 합친 구간을 말한다.

또한 뉴럴 네트워크 깊이에 따라 플래튼과 출력 사이에 한개 이상 Dense Layer 를 위치시킬 수 있다.

통상적으로 이 부분을 은닉층 Hidden Layer 이라 부르는 것 같다.

이제 우리는 레이어에 대해 간략하게 이해를 하였다.

그러나 막상 레이어를 사용 시에 고려해야할 점들이 존재한다.

예를 들어 다음과 같은 질문이 될 수 있다.

❝ Max Pooling 과 Average Pooling 중에 어떤것을 사용하여야 하는가 ? ❞

다음 포스트에서는 몇가지 레이어 Layer 를 비교해 보고자 한다.

🍀 참고

• 오픈 튜토리얼
• 텐서플로우 튜토리얼
• 텐서플로우 API 문서

• 프로그래밍과 딥러닝 차이를 알아본다.
• 딥러닝과 뉴럴 네트워크 관계를 살펴본다.

😃 프로그래밍과 딥러닝의 차이

들어가기 앞서 로직과 딥러닝의 차이를 살펴보고자 한다.

프로그램과 딥러닝 모두 입력값, 출력값 그리고 로직을 가지고 있지만 결과물이 다르다.

그림이 다소 생소할 수도 있지만 아래 그림을 살펴보자.

우리는 이해를 돕기 위해 프로그램 로직 Program 을 하나의 수식 y = 2x + 1 이라고 가정해보자.

만약 프로그램 개발중이라면, 요구사항에 마추어 출력값 y, Result 를 얻는 것이 목적이다.

이를 위해 입력값 x, Input 을 사용하여 수식 program, 2x + 1 을 구현한다.

딥러닝의 경우 수식 program, 2x + 1 를 얻는 것이 목적이다.

여기서 우리는 입력값 Input 과 출력값 Result 을 이용하게 된다.

이 때 아래와 같은 질문이 나올 수 있다.

❝ 프로그램은 수식을 구현한다면 딥러닝은 대체 무엇을 구현하는 것일까 ? ❞

사실 딥러닝에서 얻을 수 있는 프로그램 program 은 무수히 많다.

❝ 무슨 말이냐고 ? ❞

데이터 (x, y) : (1, 3), (2, 5) 가 존재한다면 완전한 수식 2x + 1 을 만들 수 있다.

여기서 데이터를 추가로 수집하여 데이터 (x, y) : (1, 3), (2, 5), (3, 8) 가 될 수 있다.

그럼 무수히 많은 수식이 나올 수 밖에 없다.

❝ 왜나하면 해가 없기 때문이다. ❞

즉, 우리는 가장 작은 오차를 가진 수식을 얻으려 할 것이고 이를 얻기 위한 방법을 구현한다.

그리고 코드를 실행시켜주면

❝ 이를 학습시킨다. 라고 표현한다. ❞

더불어 얻게된 수식을 통해 출력값을 얻는 행위를

❝ 예측한다. 라고 표현한다. ❞

😀 딥러닝과 뉴럴 네트워크 관계

예전에는 딥러닝 알고리즘 Argorithm 이라고도 표현했다.

하지만 근래 들어 알고리즘 보다는 모델 Model 이라고 부른다.

본론으로 들어와서 딥러닝 모델은 예측이 가능한 형태를 말하며

뉴럴 네트워크 Neural Network 를 학습시킨 결과물이라 생각하면 된다.

❝ 그럼 뉴럴 네트워크는 어떤 모습일까 ? ❞

그래서 익숙한 그림을 준비했다.

먼저 입력층 Input Layer 과 출력층 Output Layer 은 우리가 미리 정해 놓을 수 있다.

우리는 <강아지, 고양이> 이미지를 각각 200 by 200 크기로 500 장 수집했다.

그럼 입력층은 200 by 200 로 받아줘야 할 것이다.

나는 특별하니까 500 by 500 으로 받으려한다면

❝ 눈으로 직접 에러를 확인할 수 있을 것이다. ❞

또한 두가지 이미지를 학습했기 때문에 <강아지, 고양이> 중에 하나로 예측된다.

따라서 출력층은 2 개의 값을 뱉어낼 수 있도록 만든다.

우리는 다시 한번 똑똑한 질문을 할 수 있다.

❝ 호랑이 이미지를 넣는다면 ? ❞

조심스럽게 답해본다.

❝ 고양이가 아닐까 ? 호랑이는 고양이과 동물이니까. ❞

위와 같이 안타깝게도 둘 중 하나로만 답을 한다.

자세한 내용은 이후 포스팅에서 다룰 예정이다.

마지막으로 단일 또는 다수의 은닉층 Input Layer 은 다양하게 구성될 수 있다.

❝ 마치 어릴적 조립 설명서 없이 빌딩을 만드는 것 처럼 말이다. 우리는 논리적이니까. ❞

이 때 사용되는 구성 요소에는 Conv Layer Pooling Layer Flatten Layer Dense Layer 가 있다.

우리는 위와 같은 모든 구성 요소를 합쳐 뉴럴 네트워크라 부른다.

정리해보면 딥러닝 예측 모델을 만들기 위해서는 뉴럴 네트워크가 필요하다.

❝ 그럼 뉴럴 네트워크를 만들기 위해서는 무엇을 또 만들어야 하지 ? ❞

자주 반복되는 단어인 레이어 Layer 를 만들면 된다.

❝ 숲을 만들기 위해 나무를 심어야 하듯이 레이어는 나무와 같다. ❞

다음으로레이어에 대해 차근차근 알아보자.