✱ 핸즈온 머신러닝 14장 합성곱 신경망을 사용한 컴퓨터 비전 ✱

14.1 시각 피질 구조

시각 피질 안의 많은 뉴런이 작은 국부 수용장을 가진다. 

뉴런들은 시야의 일부 범위 안에 있는 시각 자극에만 반응한다. 

뉴런의 수용장들은 서로 겹칠 수 있어서 이를 합치면 전체 시야를 감싸게 된다. 

 

어떤 뉴런은 수평선의 이미지에만 반응하는 반면 다른 뉴런은 다른 각도의 선분에 반응하기도 한다.

어떤 두 뉴런은 동일한 수용장을 가지지만 다른 각도의 선분에 반응한다.

어떠 ㄴ뉴런은 큰 수용장을 가져서 저수준 패턴이 조합된 더 복잡한 패턴에 반응한다.

고수준 뉴런이 이웃한 저수준 뉴런의 출력에 기반한다. 

14.2 합성곱 층

CNN의 가장 중요한 구성 요소는 합성곱 층이다. 

첫 번쨰 합성곱 층의 뉴런은 입력 이미지의 모든 픽셀에 연결되는 것이 아니라 합성곱 층 뉴런의 수용장 안에 있는 픽셀에만 연결된다.

두 번째 합성곱 층에 있는 각 뉴런은 첫 번째 층의 작은 사각 영역 안에 위치한 뉴런에 연결된다.

네트워크가 첫 번째 은닉 층에서는 작은 저수준 특성에 집중하고, 그다음 은닉 층에서는 더 큰 고수준 특성으로 조합해 나가도록 도와준다.

 

지금까지 살펴본 모든 다층 신경망의 층은 한 줄로 길게 늘어선 뉴런으로 구성되었다.

-> 입력 이미지를 신경망에 주입하기 전에 1D 배열로 펼쳐야 했다.

CNN에서는 각 층이 2D로 표현되므로 뉴런을 그에 상응하는 입력과 연결하기 더 쉽다. 

 

어떤 층의 i행, j열에 있는 한 뉴런은 이전 층의 i에서 i + f_h - 1까지의 행과 j에서 j + f_w - 1까지의 열에 있는 뉴런의 출력에 연결된다.

여기서 f_h와 h_w는 이 수용장의 높이와 너비이다.

제로 패딩 : 높이와 너비를 이전 층과 같게 하기 위해 입력의 주위에 0을 추가하는 것이 일반적이다. 

 

수용장 사이에 간격을 두어 큰 입력 층을 훨씬 작은 층에 연결하는 것도 가능하며, 이렇게 함녀 모델의 게산 복잡도가 크게 줄어든다. 

스트라이드 : 한 수용장과 다음 수용장 사이의 수평 또는 수직 방향 스텝 크기

상위 층의 i행, j열에 있는 뉴런이 이전 층의 i x s_h에서 i x s_h + f_h - 1까지의 행과 j x s_w에서 j x s_w + f_w - 1까지의 열에 위치한 뉴런과 연결된다. (s_h와 s_w는 스트라이드의 수직 값과 수평 값이다.)

14.2.1 필터

뉴런의 가중치는 수용장 크기의 작은 이미지로 표현될 수 있다.

필터(합성곱 커널 또는 그냥 커널)라 불리는 두 개의 가중치 세트가 있다. 

예) 첫 번째 필터는 가운데 흰 수직선이 있는 검은 사각형이다. 이런 가중치를 사용한 뉴런은 가운데 수직선 부분을 제외하고는 수용장에 있는 모든 것을 무시한다.

두 번쨰 필터는 가운데 흰 수평선이 있는 검은 사각형이다. 이 가중치를 사용한 뉴런은 가운데 수평선 부분을 제외하고는 수용장 안의 모든 것을 무시한다. 

 

층의 전체 뉴런에 적용된 하나의 필터는 하나의 특성 맵을 만든다.

이 맵은 필터를 가장 크게 활성화시키는 이미지의 영역을 강조한다. 

수동으로 필터를 정의할 필요는 없다. <- 훈련하는 동안 합성곱 층이 자동으로 해당 문제에 가장 유용한 필터를 찾고 상위 층은 이를 연결하여 더 복잡한 패턴을 학습한다. 

14.2.2 여러 가지 특성 맵 쌓기

실제 합성곱 층은 여러 가지 필터를 가지고 필터마다 하나의 특성 맵을 출력하므로 3D로 표현하는 것이 더 정확하다. 

각 특성 맵의 픽셀은 하나의 뉴런에 해당하고 하나의 특성 맵 안에서는 모든 뉴런이 같은 파라미터(동일한 가중치와 편향)를 공유하지만, 다른 특성 맵에 있는 뉴런은 다른 파라미터를 사용한다.

한 뉴런의 수용장은 이전 층에 있는 모든 특성 맵에 걸쳐 확장된다.

하나의 합성곱 층이 입력에 여러 필터를 동시에 적용하여 입력에 있는 여러 특성을 감지할 수 있다. 

 

한 특성 맵에 있는 모든 뉴런이 같은 파라미터를 공유하기 떄문에 모델의 전체 파라미터 수가 급격하게 줄어든다.

일단 CNN이 한 지점에서 패턴을 인식하도록 학습되었다면 어떤 위치에 있는 패턴도 인식할 수 있다.

반대로 완전 연결 신경망이 한 지점에 있는 패턴을 인식하도록 학습되었다면 오직 패턴이 그 위치에 있을 때만 감지할 수 있다.

 

입력 이미지는 컬러 채널마다 하나씩 여러 서브 층으로 구성되기도 한다.

합성곱 층 l에 있는 k 특성 맵의 i행, j열에 위치한 뉴런은 이전 l - 1층에 있는 모든 특성 맵의 i x s_h에서 i x s_h + f_h - 1까지의 행과 j x s_w에서 j x s_w + f_w - 1까지의 열에 있는 뉴런의 출력에 연결된다.

다른 특성 맵이더라도 같은 층에 있는 i행과 j열에 있는 뉴런이라면 정확히 이전 층에 있는 동일한 뉴런의 출력에 연결된다.

 

[합성곱 층에 있는 뉴런의 출력 계산]

14.2.3 케라스로 합성곱 층 구현하기

from sklearn.datasets import load_sample_images
import tensorflow as tf

images = load_sample_images()["images"]
images = tf.keras.layers.CenterCrop(height=70, width=120)(images)
images = tf.keras.layers.Rescaling(scal=1 / 255)(images)

 

load_sample_image() 함수로 몇 개의 샘플 이미지를 로드하고 케라스 CenterCrop과 Rescaling 층으로 전처리했다.

images.shape
# TensorShape([2, 70, 120, 3])

첫 번째 차원은 두 개의 샘플 이미지가 있음을 설명하고, 두 번쨰와 세 번째 차원은 각 이미지가 70 x 120 크기라는 의미이다. 

마지막으로 각 픽셀은 컬러 채널당 하나의 값을 가진다. 빨강, 초록, 파랑 세 개의 채널이 있으므로 마지막 차원이 3이다. 

 

케라스는 COnvolution2D(Conv2D) 층을 제공한다. 이 층은 텐서플로의 tf.nn.conv2d() 연산을 사용ㅎ나다.

conv_layer = tf.keras.layers.Conv2D(filters=32, kernel_size=7)
fmaps = conv_layer(images)

크기가 7x7인 필터 32개로 구성된 합성곱 층이다. 그리고 이 층을 두 개의 이미지로 구성된 작은 배치에 적용했다.

fmaps.shape
# TensorShape([2, 64, 114, 32])

출력 크기는 입력 크기와 비슷하지만 두 가지가 다르다.

채널 개수가 3이 아니라 32이다.(filters=32) -> 32개의 특성 맵이 출력되었다. 각 위치에서 빨강, 초록, 파랑의 강도 대신 각각의 특성 강도를 얻었다.

높이와 너비는 6픽셀씩 줄어들었다. Conv2D 층이 기본적으로 제로 패딩을 사용하지 않기 때문이다. -> 필터의 크기에 따라 출력 특성 맵의 가장자리에서 몇 개의 픽셀을 잃는다. 

 

대신 padding="same"이라 지정하면 출력 특성 맵이 입력과 같은 크기가 되도록 입력 가장자리에 충분한 패딩이 추가된다. 

conv_layer = tf.keras.layers.Conv2D(filters=32, kernel_size=7,
...                                 padding="same")
...
fmaps = conv_layer(images)
fmaps.shape
# TensorShape([2, 70, 120, 32])

 

스트라이드가 1보다 크면 padding="same"으로 지정해도 출력 크기가 입력 크기와 같지 않게 된다. 

 

 

[출력 크기가 계산되는 방식]

 

Dense 층과 마찬가지로 Conv2D 층은 커널과 편향을 포함해 모든 가중치를 가지고 있다.

커널은 랜덤하게 초기화되고 편향은 0으로 초기화된다.

이런 가중치는 weights 속성을 통해 텐서플로 변수나 get_weights() 함수를 통해 넘파이 배열로 참조할 수 있다.

kernels, biases = conv_layer.get_weights()
kernels.shape
# (7, 7, 3, 32)
biases.shape
# (32,)

kernels 배열은 4D이고 크기는 [kernel_height, kernel_width, input_channels, output_channels]이다.

biases 배열은 1D이고 크기는 [output_channels]이다.

출력 채널의 개수는 출력 특성 맵의 개수와 같으며 필터의 개수와도 같다.

 

입력 이미지의 높이와 너비가 커널 크기에 나타나지 않는다는 점이 중요하다. 

출력 특성 맵에 있는 모든 뉴런이 동일한 가중치를 공유하기 때문이다.

이미지가 적어도 커널만큼 크고 채널 개수가 맞다면 이 층에 어떤 크기의 이미지도 입력할 수 있다는 의미이다. 

 

Conv2D 층을 만들 때 일반적으로 ReLU와 같은 활성화 함수와 He 초기화 같은 커널 초기화 방법을 지정한다. 

Dense 층과 마찬가지로 합성곱 층은 선형 연산을 수행하기 때문에 활성화 함수 없이 여러 개의 합성곱 층을 쌓아도 하나의 합성곱 층과 동일하며 복잡한 것을 학습할 수 없게 된다.

 

합성곱 층에는 여러 개의 하이퍼파라미터가 있다. (filters, kernel_size, padding, strides, activation, kernel_initializer 등)

최적의 하이퍼파라미터 값을 찾기 위해 교차 검증을 사용할 수 있지만 시간이 많이 소요된다.

---

14.3 풀링 층

풀링 층의 목적은 계산량과 메모리 사용량, 과대적합의 위험을 줄여주는 파라미터 수를 줄이기 위해 입력 이미지의 부표본(축소본)을 만드는 것이다.

 

합성곱 층에서와 마찬가지로 풀링 층의 각 뉴런은 이전 층의 작은 사각 영역의 수용장 안에 있는 뉴런의 출력과 연결되어 있다. 

이전과 동일하게 크기, 스트라이드, 패딩 유형을 지정해야 한다.

하지만 풀링 뉴런은 가중치가 없으며, 최대나 평균 같은 합산 함수를 사용해 입력값을 더하는 것이 전부이다.

최대 풀링 층의 경우 각 수용장에서 가장 큰 입력값이 다음 층으로 전달되고 다른 값은 버려진다. 

보통 모든 입력 채널에 독립적으로 적용되므로 출력의 깊이(채널 개수)가 입력의 깊이와 동일하다.

최대 풀링은 작은 변화에도 일정 수준의 불변성을 만들어준다.

CNN에서 몇 개 층마다 최대 풀링 층을 추가하면 전체적으로 일정 수준의 이동 불변성을 얻을 수 있다.

회전과 확대, 축소에 대해 약간의 불변성을 제공한다.

이와 같은 불변성은 분류 작업처럼 예측이 이런 작은 부분에서 영향을 받지 않는 경우 유용할 수 있다. 

하지만 매우 파괴적이라는 단점이 있다.

---

14.4 케라스로 풀링 층 구현하기

max_pool = tf.keras.layers.MaxPool2D(pool_size=2)

스트라이드의 기본값은 커널 크기이므로 이 층은 (수평과 수직 모두) 스트라이드 2를 사용한다.

기본적으로 "valid" 패딩을 사용한다. (패딩을 하지 않는다.)

 

평균 풀링 층을 만드려면 MaxPool2D 대신 AveragePooling2D(AvgPool2D)를 사용해야 한다.

평균을 게산하면 최댓값을 계산하는 것보다 정보 손실이 적지만, 최대 플링은 다음 층이 조금 더 명확한 신호로 작업할 수 있으며 강력한 이동 불변성을 제공하고 연산 비용이 조금 덜 든다.

 

최대 풀링과 평균 풀링은 공간 차우너이 아니라 깊이 차원으로 수행될 수 있다.

-> CNN이 다양한 특성(두께, 밝기, 왜곡, 색상 등)에 대한 불변성을 학습할 수 있다. 

 

[깊이 방향 최대 풀링]

회전에 대한 불변성을 학습할 수 있다.

class DepthPool(tf.keras.layers.Layer):
    def __init__(self, pool_size=2, **kwargs):
        super().__init__(**kwargs)
        self.pool_size = pool_size
        
    def call(self, inputs):
        shape = tf.shape(inputs) # shape[-1]은 채널 개수이다.
        groups = shape[-1] // self.pool_size # 채널 그룹의 개수
        new_shape = tf.concat([shape[:-1], [groups, self.pool_size]], axis=0)
        return tf.reduce_max(tf.reshape(inputs, new_shape), axis=-1)

입력의 채널을 원하는 크기의 그룹으로 나눈다. 그다음 tf.reduce_max()를 사용해 각 그룹의 최댓값을 계산한다.

스트라이드가 풀링 크기와 같다고 가정하는 코드이다. 

 

현대적인 신경망 구조에서 종종 보게될 마지막 풀링 층은 전역 평균 풀링 층이다.

이 층에서는 각 특성 맵의 평균을 계산한다. (입력과 공간 방향 차원이 같은 커널을 사용하는 풀링 층과 같다.)

각 샘플의 특성 맵마다 하나의 숫자를 출력한다. 

GlobalAveeragePooling2D(GlobalAvgPool2D) 클래스를 사용한다. 

global_avg_pool = tf.keras.layers.GlobalAvgPool2D()

global_avg_pool = tf.keras.layers.Lambda(
    lambda X: tf.reduce_mean(X, axis=[1, 2]))

공간 방향(높이와 너비)을 따라 평균을 계산하는 Lambda 층과 동등하다.

 

global_avg_pool(images_
# <tf.Tensor: shape=(2, 3), dtype=float32, numpy=
# array([[0.64338624, 0.5971759, 0.5824972 ],
#        [0.76306933, 0.26011038, 0.10849128]], dtype=float32)>

이 층에 입력 이미지를 적용하면 각 이미지의 빨강, 초록, 파랑 색의 평균 강도를 얻을 수 있다.

---

14.5 CNN 구조

전형적인 CNN 구조는 합성곱 층을 몇 개 쌓고(각각 ReLU 층을 그 뒤에 놓고), 그다음에 풀링 층을 쌓고, 그다음에 또 합성곱 층(+ReLU)을 몇 개 더 쌓고, 그다음에 다시 풀링 층을 쌓는 식이다.

네트워크를 통과하여 진행할수록 이미지는 점점 작아지지만 합성곱 층 때문에 일반적으로 점점 더 깊어진다. (더 많은 특성 맵을 가진다.)

맨 위층에는 몇 개의 완전 연결 층(+ReLU)으로 구성된 일반적인 피드포워드 신경망이 추가되고 마지막 층(클래스 확률을 추정하기 위한 소프트맥스 층)에서 예측을 출력한다.

from functools import partial

DefaultConv2D = partial(tf.keras.layers.Conv2D, kernel_size=3, padding="same",
                        activation="relu", kernel_initializer="he_normal")
                        
model = tf.keras.Sequential([
    DefaultConv2D(filters=64, kernel_size=7, input_shape=[28, 28, 1]),
    tf.keras.layers.MaxPool2D(),
    DefualtConv2D(filters=128),
    DefualtConv2D(filters=128),
    tf.keras.layers.MaxPool2D(),
    DefualtConv2D(filters=256),
    DefualtConv2D(filters=256),
    tf.keras.layers.MaxPool2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(units=128, activation="relu",
                         kernel_initializer="he_normal"),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(units=64, activation="relu",
                         kernel_initializer="he_normal"),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(units=10, activation="softmax")
])

functools.partial() 함수를 사용해 Conv2D와 같지만 기본 매개변수 값이 다른 DefaultConv2D를 정의한다. 커널 크기는 3이고 "same" 패딩, RELU 활성화 함수, He 초기화를 사용한다.

Sequential 모델을 만든다. 첫 번쨰 층은 7x7의 필터 64개를 가진 DefaultConv2D이다. 입력 이미지가 크지 않기 때문에 스트라이드 기본값 1을 사용한다. 이미지가 28x28 픽셀이고 컬러 채널이 흑백 하나이므로 input_shape=[28, 28, 1]로 지정한다. 경우에 따라 채널 차원을 추가하기 위해 np.reshape() 또는 np.expand_dims()를 사용해야 할 수도 있고, 모델의 첫 번째 층으로 Reshape 층을 사용할 수 있다.

풀링 크기가 2인 최대 풀링 층을 추가하여 공간 방향 차원을 절반으로 줄인다.

이와 동일한 구조를 두 번 반복한다. 최대 풀링 층이 뒤따르는 합성곱 층이 두 번 등장한다. 이미지가 클 때는 이 구조를 더 많이 반복할 수 있다. 반복 횟수는 튜닝해야 할 하이퍼파라미터이다.

CNN이 출력 층에 다다를수록 필터 개수가 늘어난다. 저수준 특성의 개수는 적지만 이를 연결하여 고수준 특성을 만들 수 있는 방법이 많기 때문에 이런 구조가 합리적이다. 풀링 층 다음에 필터 개수를 두 배로 늘리는 것이 일반적인 방법이다. 훌링 층이 공간 방향 차원을 절반으로 줄이므로 이어지는 층에서 파라미터 개수, 메모리 사용량, 계산 비용을 크게 늘리지 않고 특성 맵 개수를 두 배로 늘릴 수 있다.

두 개의 은닉 층과 하나의 출력 층으로 구성된 완전 연결 네트워크이다. 밀집 층은 샘플의 특성으로 1D 배열을 기대하므로 첫 번째 밀집 층 이전에 입력을 일렬로 펼쳐야 한다. 또 과대적합을 줄이기 위해 밀집 층 사이에 50%의 드롭아웃 비율을 가진 드롭아웃 층을 추가한다. 

14.5.1 LeNet-5

합성곱 층과 풀링 층을 쌓고 밀집 층이 뒤따른다.

최신 분류 CNN과 가장 크게 차이나는 점은 활성화 함수이며 요즘에는 tanh 대신 ReLU를 사용하고 RBF 대신 소프트맥스를 사용한다. 

14.5.2 AlexNet

더 크고 깊을 뿐 LeNet-5와 비슷하며, 처음으로 합성곱 층 위에 풀링 층을 쌓지 않고 바로 합성곱 층끼리 쌓았다.

 

과대적합을 줄이기 위해 두 가지 규제 기법을 사용한다.

첫 번째는 훈련하는 동안 F9과 F10의 출력에 드롭아웃을 50% 비율로 적용했다.

두 번째는 훈련 이미지를 랜덤하게 여러 간격으로 이동하거나 수평으로 뒤집고 조명을 바꾸는 식으로 데이터 증식을 수행했다. 

 

데이터 증식 : 진짜 같은 훈련 샘플을 인공적으로 생성하여 훈련 세트의 크기를 늘린다. 과대적합을 줄이는 규제 기법이다.

생성된 샘플은 가능한 진짜에 가까워야 한다. 

이상적으로는 증식된 훈련 세트에서 이미지를 뽑았을 때 증식된 것인지 아닌지를 구분할 수 없어야 한다.

단순한 백색 잡음을 추가하는 것은 도움이 되지 않으며 증식 방식이 학습 가능해야 한다.

클래스 빈도가 작은 샘플을 늘릴 수 있기 때문에 불균형한 데이터셋을 다룰 때도 유용하다. (SMOTE)

 

AlexNet은 C1과 C3 층의 ReLU 단계 후에 바로 LRN(local response normalization)이라 부르는 경쟁적인 정규화 단계를 사용한다. 

가장 강하게 활성화된 뉴런이 다른 특성 맵에 있는 같은 위치의 뉴런을 억제한다.

이는 특성 맵을 각기 특별하게 다른 것과 구분되게 하고, 더 넓은 시각에서 특징을 탐색하도록 만들어 결국 일반화 성능을 향상시킨다. 

14.5.3 GoogLeNet

네트워크가 이전 CNN보다 훨씬 더 깊다.

인셉션 모듈이라는 서브 네트워크를 가지고 있어서 GoogLeNet이 이전의 구조보다 효과적으로 파라미터를 사용한다.

 

[인셉션 모듈의 구조]

3x3+1(s) 표시는 3x3 커널, 스트라이드 1, "same" 패딩을 사용한다는 뜻이다.

처음에 입력 신호가 네 개의 다른 층에 주입되며 모든 합성곱 층은 ReLU 활성화 함수를 사용한다.

위쪽의 합성곱 층은 각기 다른 커널 크기를 사용하여 다른 크기의 패턴을 잡는다.

모든 층은(최대 풀링 층조차도) 스트라이드 1과 "same" 패딩을 사용하므로 출력의 높이와 너비가 모두 입력과 같다.

이렇게 하면 모든 출력을 깊이 연결 층에서 깊이 방향으로 연결할 수 있다. (== 위쪽 네 개의 합성곱 층에서 만든 특성 맵을 쌓는다.)

이 층은 케라스 기본값 axis=-1로 지정한 Concatenate 층을 사용해 구현할 수 있다. 

 

인셉션 모듈은 1x1 커널의 합성곱 층을 가진다.

공간상의 패턴을 잡을 수는 없지만 깊이 차원(채널)을 따라 놓인 패턴을 잡을 수 있다.

입력보다 더 적은 특성 맵을 출력하므로 차원을 줄인다는 의미인 병목 층의 역할을 담당한다. 연산 비용과 파라미터 개수를 줄여 훈련 속도를 높이고 일반화 성능을 향상한다. 

합성곱 층의 쌍이 더 복잡한 패턴을 감지할 수 있는 한 개의 강력한 합성곱 층처럼 작동한다. 하나의 합성곱 층은 하나의 밀집 층으로 이미지를 훑는 것과 같고 합성곱 층의 쌍은 두 개의 층을 가진 신경망으로 이미지를 훑는 것과 같다. 

 

전체 인셉션 모듈은 여러 크기의 복잡한 패턴이 담긴 특성 맵을 출력하는 합성곱 층이다. 

 

GoogLeNet은 실제로 네트워크를 하나로 길게 쌓은 구조이고, 9개의 인셉션 모듈을 포함하고 있다.

인셉션 모듈에 있는 여섯 개의 숫자는 모듈 안에 있는 합성곱 층에서 출력하는 특성 맵의 수를 나타낸다. 

모든 합성곱 층은 ReLU 활성화 함수를 사용한다. 

처음 두 층은 계산량을 줄이기 위해 이미지의 높이와 너비를 4배로 줄인다. (면적은 16배 줄어든다.) 많은 정보를 유지하기 위해 첫 번쨰 층은 큰 크기의 커널(7x7)을 사용한다. 

LRN 층은 이전 층이 다양한 특성을 학습하도록 만든다. 

이어지는 두 개의 학성곱 층 중에서 첫 번째 층이 병목 층처럼 작동한다. 이 합성곱 쌍을 하나의 똑똑한 합성곱 층으로 생각할 수 있다.

다시 한번 LRN 층이 이전 층이 다양한 패턴을 학습하도록 만든다. 

그런 다음 최대 풀링 층이 계산 속도를 높이기 위해 이미지의 높이와 너비를 2배로 줄인다.

9개의 인셉션 모듈이 길게 이어지고, 차원 감소와 속도 향상을 위해 몇 개의 최대 풀링 층을 끼워넣었다.

전역 평균 풀링 층이 각 특성 맵의 평균을 출력한다. 남아 있는 공간 정보가 많지 않기 때문에 여기서는 공간 방향 정보를 모두 잃는다. 이 층에서 수행된 차원 축소 덕분에 CNN 위에 몇 개의 완전 연결 층을 둘 필요가 없다.

규제를 위한 드롭아웃 층 다음에 1,000개의 유닛과 소프트맥스 활성화 함수를 적용한 완전 연결 층으로 클래스 확률 추정값을 출력한다. 

 

원본 GoogLeNet 구조는 세 번째와 여섯 번째 인셉션 모듈 위에 연결된 두 개의 부가적인 분류기를 포함한다.

이들은 모두 하나의 평균 풀링 층, 하나의 합성곱 층, 두 개의 완전 연결 층, 소프트맥스 활성화 층으로 구성되어 있다.

훈련하는 동안 여기에서의 손실이 전체 손실에 더해진다.

-> 그레이디언트 소실 문제를 줄이고 네트워크를 규제하나 효과가 비교적 작다. 

14.5.4 VGGNet

2개 또는 3개의 합성곱 층 뒤에 풀링 층이 나오고 다시 2개 또는 3개의 합성곱 층과 풀링 층이 등장한다.

마지막 밀집 네트워크는 2개의 은닉 층과 출력 층으로 이루어진다.

많은 개수의 필터를 사용하지만 3x3 필터만 사용한다. 

14.5.5 ResNet (잔차 네트워크)

152개의 층으로 구성된 극도로 깊은 CNN을 사용한다. 

더 적은 파라미터를 사용해 점점 더 깊은 네트워크로 컴퓨터 비전 모델을 구성하는 일반적인 트렌드를 만들었다.

이런 깊은 네트워크를 훈련시킬 수 있는 핵심 요소는 스킵 연결(숏컷 연결)이다.

어떤 층에 주입되는 신호가 상위 층의 출력에도 더해진다. 

 

신경망을 훈련시킬 때는 목적 함수 h(x)를 모델링하는 것이 목표이다.

만약 입력 x를 네트워크의 출력에 더한다면(스킵 연결을 추가하면) 네트워크는 h(x) 대신 f(x) - h(x) - x를 학습하게 된다. (잔차 학습)

 

일반적인 신경망을 초기화할 때는 가중치가 0에 가깝기 때문에 네트워크도 0에 가까운 값을 출력한다. 

스킵 연결을 추가하면 이 네트워크는 입력과 같은 값을 출력한다.

즉, 초기에는 항등 함수를 모델링한다. 

목적 함수가 항등 함수에 매우 가깝다면 훈련 속도가 매우 빨라진다. 

 

스킵 연결을 많이 추가하면 일부 층이 아직 학습되지 않았더라도 네트워크는 훈련을 시작할 수 있다.

스킵 연결 덕분에 입력 신호가 전체 네트워크에 손쉽게 영향을 미치게 된다.

심층 잔차 네트워크는 스킵 연결을 가진 작은 신경망인 잔차 유닛(RU)을 쌓은 것으로 볼 수 있다. 

[일반적인 심층 신경망(왼쪽)과 심층 잔차 네트워크(오른쪽)]

 

ResNet은 GoogLeNet과 똑같이 시작하고 종료하지만, 중간에 단순한 잔차 유닛을 매우 깊게 쌓는다.

각 잔차 유닛은 배치 정규화(BN)와 ReLU, 3x3 커널을 사용하고 공간 정보를 유지하는(스트라이드 1, "same" 패딩) 두 개의 합성곱 층(풀링 층이 없다)로 이루어져 있다. 

특성 맵의 수는 몇 개의 잔차 유닛마다 두 배로 눌어나고 (스트라이드 2인 합성곱 층을 사용해서) 높이와 너비는 절반이 된다.

이러한 경우 입력과 출력의 크기가 다르기 떄문에 입력이 잔차 유닛의 출력에 바로 더해질 수 없다.

이 문제를 해결하기 위해 스트라이드 2이고 출력 특성 맵의 수가 같은 1x1 합성곱 층으로 입력을 통과시킨다. 

[특성 맵의 크기와 깊이가 바뀔 때 스킵 연결]

14.5.6 Xception

GoogLeNet과 ResNet의 아이디어를 합쳤지만 인셉션 모듈은 깊이별 분류 합성곱 층(분리 합성곱 층)이라는 특별한 층으로 대체했다.

일반적인 합성곱 층은 공간상의 패턴(예. 타원 형태)과 채널 사이의 패턴(예. 입+코+눈=얼굴)을 동시에 잡기 위해 필터를 사용한다. 

반면 분리 합성곱 층은 공간 패턴과 채널 사이 패턴을 분리하여 모델링할 수 있다고 가정한다.

이 층은 두 개의 부분으로 구성되며, 첫 번쨰 부분은 하나의 공간 필터를 각 입력 특성 맵에 적용하고 두 번째 부분은 채널 사이 패턴만 조사한다. (1x1 필터를 사용한 일반적인 합성곱 층)

분리 합성곱 층은 입력 채널마다 하나의 공간 필터만 가지기 때문에 입력 층과 같이 채널이 너무 적은 층 다음에 사용하는 것을 피해야 한다. 

-> Xception 구조는 2개의 일반 합성곱 층으로 시작한다.

이 구조의 나머지는 분리 합성곱만 사용하며, 거기에 몇 개의 최대 풀링 층과 전형적인 마지막 층들(전역 평균 풀링 층과 밀집 출력 층)을 사용한다. 

 

인셉션 모듈이 전혀 없는데 Xception을 GooLeNet의 변형으로 간주하는 이유:

인셉션 모듈은 1x1 필터를 사용한 합성곱 층을 포함하며 이 층은 채널 사이 패턴만 감지한다.

하지만 이 위에 놓인 합성곱 층은 공간과 채널 패턴을 모두 감지하는 일반적인 합성곱 층이다.

따라서 인셉션 모듈을 (공간 패턴과 채널 패턴을 함께 고려하는) 일반 합성곱 층과 (따로 고려하는) 분리 합성곱 층의 중간 형태로 생각할 수 있다. 

14.5.7 SENet

원래 구조에 있는 모든 인셉셜 모듈이나 모든 잔차 유닛에 SE 블록이라는 작은 신경망을 추가하여 성능을 향상했다. 

SE 블록이 추가된 부분의 유닛의 출력을 깊이 차원에 초점을 맞추어 분석한다. (공간 패턴은 신경 쓰지 않는다.)

어떤 특성이 일반적으로 동시에 가장 크게 활성화되는지 학습한 다음, 이 정보를 사용하여 특성 맵을 보정한다.

하나의 SE 블록은 3개의 층으로 구성된다. 

전역 평균 풀링 층과 ReLU 활성화 함수를 사용하는 밀집 은닉 층, 시그모이드 활성화 함수를 사용하는 밀집 출력 층이다. 

처음에 전역 평균 풀링 층이 각 특성 맵에 대한 평균 활성화 값을 계산한다.

예) 256개의 특성 맵을 가진 입력이라면 각 필터의 전반적인 응답 수준을 나타내는 256개의 숫자가 출력된다.

다음 층에서 압축이 일어난다. 이 층은 256개보다 훨씬 적은 뉴런을 가진다. 일반적으로 특성 맵 개수보다 16배 적다.

예) 256개의 숫자가 작은 벡터(16차원)로 압축된다.

이 저차원 벡터(하나의 임베딩)는 특성 응답의 분포를 표현한다.

이 병목 층을 통해 SE 블록이 특성 조합에 대한 일반적인 표현을 학습한다.

마지막으로 출력 층은 이 임베딩을 받아 특성 맵마다 0과 1 사이의 하나의 숫자를 담은 모정된 벡터(256개)를 출력한다.

그다음 특성 맵과 이 보정된 벡터를 곱해 관련없는 (보정된 점수가 낮은)특성값을 낮추고 관련 있는 (보정된 점수가 1에 가까운) 특성값은 그대로 유지한다. 

---

14.6 케라스로 ResNet-34 CNN 구현하기

먼저 ResidualUnit 층을 만든다.

DefualtConv2D = partial(tf.keras.layers.Conv2D, kernel_size=3, strides=1,
                        padding="same", kernel_initializer="he_normal",
                        use_bias=False)
                        
class ResidualUnit(tf.keras.layers.Layer):
    def __init__(self, filters, strides=1, activation="relu", **kwargs):
        super().__init__(**kwargs)
        self.activation = tf.keras.activations.get(activation)
        self.main_layers = [
            DefaultConv2D(filters, strides=strides),
            tf.keras.layers.BatchNormalization(),
            self.activation,
            DefaultConv2D(filter),
            tf.keras.layers.BatchNormalization()
        ]
        self.skip_layers = []
        if strides > 1:
            self.skip_layers = [
                DefaultConv2D(filters, kernel_size=1, strides=strides),
                tf.keras.layers.BatchNormalization()
            ]
    
    def call(self, inputs):
        Z = inputs
        for layer in self.main_layers:
            Z = layer(Z)
        skip_Z = inputs
        for layer in self.skip_layers:
            skip_Z = layer(skip_Z)
        return self.activation(Z + skip_Z)

call() 메서드에서 입력을 main_layers와 (skip_layers가 있다면) skip_layers에 통과시킨 후 두 출력을 더하여 활성화 함수를 적용한다.

 

이 네트워크는 연속되어 길게 연결된 층이기 때문에 Sequential 클래스를 사용해 ResNet-34 모델을 만들 수 있다. 

ResidualUnit 클래스를 준비해놓았으니 잔차 유닛을 하나의 층처럼 취급할 수 있다.

model = tf.keras.Sequential([
    DefaultConv2D(64, kernel_size=7, strides=2, input_shape=[224, 224, 3]),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.Activation("relu"),
    tf.keras.layers.MaxPool2D(pool_size=3, strides=2, padding="same"),
])
prev_filters = 64
for filters in [64] * 3 + [128] * 4 + [256] * 6 + [512] * 3:
    strides = 1 if filters == prev_filters else 2
    model.add(ResidualUnit(filters, strides=strides))
    prev_filters = filters
    
model.add(tf.keras.layers.GlobalAvgPool2D())
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(10, activation="softmax"))

---

14.7 케라스의 사전 훈련 모델 사용하기

model = tf.keras.applizations.resnet50.ResNet50(weights="imagenet")

ResNet-50 모델을 만들고 이미지넷 데이터셋에서 사전 훈련된 가중치를 다운로드한다.

images = load_sample_images()["images"]
images_resized = tf.keras.lyaers.Resizing(height=224, width=224,
                                          crop_to_aspect_radio=True)(images)

케라스의 Resizing 층을 이용해 샘플 이미지 두 개의 크기를 바꿀 수 있다.

inputs = tf.keras.applications.resnet50.preprocess_input(images_resized)

사전 훈련된 모델은 이미지가 적절한 방식으로 전처리되었다고 가정한다.

경우에 따라 0에서 1 사이 또는 -1에서 1 사이의 입력을 기대한다.

이를 위해 모델마다 이미지를 전처리해주는 preprocess_input() 함수를 제공한다.

Y_proba = model.predict(inputs)
Y_proba.shape
# (2, 1000)

사전 훈련된 모델을 사용해 예측을 수행할 수 있다. 

출력 Y_proba는 행이 하나의 이미지이고 열이 하나의 클래스인 행렬이다.

top_K = tf.keras.applizations.resnet50.decode_predictions(Y_prova, top=3)
for image_index in range(len(images)):
    print(f"Image #{image_index}")
    for class_id, name, y_proba in top_K[image_index]:
        print(f" {class_id} - {name:12s} {y_proba:.2%}")

최상위 K개의 예측을 클래스 이름과 예측 클래스의 추정 확률을 출력하려면 decode_predictions() 함수를 사용한다.

이 함수는 각 이미지에 대해 최상위 K개의 예측을 담은 리스트를 반환한다.

각 예측은 클래스 IP(class_id), 이름(name), 확률(y_proba)을 포함한 튜플이다.

# Image #0
# n03877845 - palace     54.69%
# n03781244 - monastery  24.72%
# n02825657 - bell_cote  18.55%

# Image #1
# n04522168 - vase       32.66%
# n11939491 - daisy      17.81%
# n03530642 - honeycomb  12.06%

---

14.8 사전 훈련된 모델을 사용한 전이 학습

import tensorflow_datasets as tfds

dataset, info = ftds.load("tf_flowers", as_supervised=True, with_info=True)
dataset_size = info.splits["train"].num_examples # 370
class_names = info.features["label"].names       # ["dandelion", "daisy", ...]
n_classes = info.features["label"].num_classes   # 5

텐서플로 데이터셋을 사용해 데이터를 적재한다.

with_info=True로 지정하면 데이터셋에 관한 정보를 얻을 수 있다. 

test_set_raw, valid_set_raw, train_set_raw = tfds.load(
    "tf_flowers",
    split=["train[:10%]", "train[10%:25%]", "train[25%:]"],
    as_supervised=True)

데이터셋을 테스트 세트, 검증 세트, 훈련 세트로 나눈다.

batch_size = 32
preprocess = tf.keras.Sequential([
    tf.keras.layers.Resizing(height=224, width=224, crop_to_aspect_ratio=True),
    tf.keras.layers.Lambda(tf.keras.applications.xception.preprocess_input)
])
train_set = train_set_raw.map(lambda X, y: (preprocess(X), y))
trian_set = train_set.shuffle(1000, seed=42).batch(batch_size).prefetch(1)
valid_set = valid_set_raw.map(lambda X, y: (preprocess(X), y)).batch(batch_size)
test_set = test_set_raw.map(lambda X, y: (preprocess(X), y)).batch(batch_size)

세 데이터셋 모두 이미지를 낱개로 포함하고 있다.

이를 배치로 묶어야 하지만 먼저 이미지 크기가 모두 동일한지 확인해야 한다. (그렇지 않으면 묶을 수 없다.)

또한 Xception 모델에 맞도록 이미지를 전처리하기 위해 tf.keras.applications.xception.preprocess_input() 함수를 호출해야 한다.

마지막으로 훈련 세트를 섞고 프리페칭한다.

data_augmentation = tf.keras.Sequential([
    tf.keras.layers.RandomFlip(mode="horizontal", seed=42),
    tf.keras.layers.RandomRotation(factor=0.05, seed=42),
    tf.keras.layers.RandomContrast(factor=0.2, seed=42)
])

이 데이터셋은 아주 크지 않기 때문에 약간의 데이터 증식이 도움이 된다.

훈련하는 동안 이미지를 수평으로 랜덤하게 뒤집고, 약간 회전하고, 명암을 조절한다.

데이터 증식을 추가하고 싶다면 훈련 세트에 대한 전처리 함수를 바꾸어 훈련 이미지를 랜덤하게 변환하면 된다.

ft.image.random_crop() 함수로 이미지를 랜덤하게 자르거나 tf.image.random_flip_left_right() 함수로 이미지를 수평으로 랜덤하게 뒤집는 식이다. 

base_model = tf.keras.applications.xception.Xception(weights="imagenet",
                                                     include_top=False)
avg = tf.keras.layers.GlobalAveragePooling2D()(base_model.output)
output = tf.keras.layers.Dense(n_classes, activation="softmax")(avg)
model = tf.keras.Model(inputs=base_model.input, outputs=output)

이미지넷에서 사전 훈련된 Xception 모델을 로드한다.

include_top=False로 지정하여 네트워크의 최상 층에 해당하는 전역 평균 풀링 층과 밀집 출력 층을 제외시킨다.

이 기반 모델의 출력을 바탕으로 새로운 전역 평균 풀링 층을 추가하고 그 뒤에 클래스마다 하나의 유닛과 소프트맥스 활성화 함수를 가진 밀집 출력 층을 놓는다.

마지막에 케라스의 Model로 이를 모두 감싼다.

for layer in base_model.layers:
    layer.trainable = False

훈련 초기에는 사전 훈련된 층의 가중치를 동결하는 게 좋다.

optimizer = tf.keras.optimizers.SGD(learning_rate=0.1, momentum=0.9)
model.compile(loss="sparse_categorical_crossentropy", optimizer=optimizer,
              metrics=["accuracy"])
history = model.fit(train_set, validation_data=valid_set, epochs=3)

모델을 컴파일하고 훈련을 시작한다. 

 

for layer in base_model.layers[56:]:
    layer.trainable = True

모델을 몇 번의 에포크 동안 훈련하면 검증 정확도가 더 나아지지 않는 순간이 생기는데 이는 새로 추가한 최상위 층이 잘 훈련되었음을 의미한다.

-> 기반 모델의 상위 층 일부의 동결을 해제하고 훈련을 계속한다.

optimizer = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)
model.compile(loss="sparse_categorical_crossentropy", optimizer=optimizer,
              metrics=["accuracy"])
history = model.fit(train_set, validation_data=valid_set, epochs=10)

층을 동결하거나 해제할 떄 모델을 다시 컴파일해야 한다.

사전 훈련된 가중치가 훼손되는 것을 피하기 위해 훨씬 작은 학습률을 사용한다. 

---

14.9 분류와 위치 추정

사진에서 물체의 위치를 추정하는 것은 회귀 작업으로 나타낼 수 있다. 

물체 주위의 바운딩 박스를 예측하는 것인데, 일반적인 방법은 물체 중심의 수평, 수직 좌표와 높이, 너비를 예측하는 것이다. 

일반적으로 전역 평균 풀링 층 위에 네 개의 유닛을 가진 두 번째 밀집 출력 층을 추가하고 MSE 손실을 사용해 훈련한다.

base_model = tf.keras.applications.xception.Xception(weights="imagenet",
                                                     include_top=False)
avg = tf.keras.layers.GlobalAveragePooling2D()(base_model.output)
class_output = tf.keras.lauers.Dense(n_classes, activation="softmax")(avg)
loc_output = tf.keras.layers.Dense(4)(avg)
model = tf.keras.Model(inputs=base_model.input,
                       outputs=[class_output, loc_output])
model.compile(loss=["sparse_categorical_crossentropy", "mse"],
              loss_wieghts=[0.8, 0.2],
              optimizer=optimizer, metrics=["accuracy"]

꽃 데이터셋은 꽃 주위에 바운딩 박스를 가지고 있지 않아 직접 만들어 추가해야 된다.

레이블은 만드는 것은 머신러닝 프로젝트에서 가장 어렵고 비용이 많이 드는 작업이다.

시간을 들여 적절한 도구를 찾는 것이 좋다.

 

꽃 데이터셋의 모든 이미지에 대해 바운딩 박스가 준비되었다고 가정한다.

클래스 레이블, 바운딩 박스와 함꼐 전처리된 이미지의 배치가 하나의 원소인 데이터셋을 만들어야 한다. 

각 원소는 (images, (class_labels, bounding_boxes)) 형태의 튜플이 된다.

 

MSE를 모델 훈련을 위한 손실 함수로 사용할 수 있다. 하지만 모델이 바운딩 박스를 얼마나 잘 예측하는지 평가하는 데 좋은 지표는 아니다.

-> 바운딩 박스에 널리 사용되는 지표는 IoU이다.

예측한 바운딩 박스와 타깃 바운딩 박스 사이에 중첩되는 영역을 전체 영역으로 나눈 것이다. (tf.keras.metrics.MeanIoU)

---

14.10 객체 탐지

하나의 이미지에서 여러 물체를 분류하고 위치를 추정하는 작업을 의미한다.

 

몇 년 전까지 널리 사용되던 방법은 이미지 중앙에 놓인 하나의 물체를 분류하고 위치를 찾는 CNN을 훈련한 다음 이 CNN으로 이미지 위를 훑으면서 각 위치에서 예측을 만드는 것이다. 

이 CNN은 일반적으로 클래스 확률과 바운딩 박스 외에도 객체성 점수를 예측하도록 훈련된다.

이는 이미지의 중앙부에 실제 객체가 있는지에 대한 추정 확률이다.

이 값은 이진 분류 출력이므로 하나의 유닛과 시그모이드 활성화 함수를 가진 밀집 출력 층을 사용하고 이진 크로스 엔트로피 손실로 훈련하여 만들 수 있다. 

전체 이미지에 걸쳐 이 CNN을 슬라이딩하면 3x5 그리드로 구성된 총 15개의 바운딩 방스 예측이 만들어지고 각 바운딩 박스에는 추정 클래스 확률과 객체성 점수가 함께 표시된다.

이 방식은 매우 쉽지만 조금씩 다른 위치에서 동일한 물체를 여러 번 감지하는 경우가 많아 불필요한 바운딩 박스를 제거하기 위한 사후 처리가 필요하다. (NMS)

 

[NMS 방법]

 

이 방법은 CNN을 여러 번 실행시켜야 하므로 많이 느리다.

완전 합성곱 신경망(FCN)을 사용하면 CNN을 훨씬 더 빠르게 이미지에 슬라이딩시킬 수 있다.

14.10.1 완전 합성곱 신경망

CNN 맨 위의 밀집 층을 합성곱 층으로 바꿀 수 있다.

밀집 층은 입력 특성마다 하나의 가중치를 두므로 특정 입력 크기를 기대하지만 합성곱 층은 어떤 크기의 이미지도 처리할 수 있다.

대신 합성곱 층은 입력 채널마다 커널 가중치가 달라서 특정 개수의 채널을 기대한다.

FCN은 합성곱 층만 가지므로 어떤 크기의 이미지에서도 훈련하고 실행할 수 있다. 

 

이미지를 딱 한 번만 처리하기 때문에 효율적이다.

14.10.2 YOLO

각 격자 셀에서 바운딩 박스 중심이 셀 안에 있는 객체만 고려한다. 바운딩 박스 좌표는 셀에 상대적이다. (0, 0)은 셀의 왼쪽 상단을 의미하고 (1, 1)은 오른쪽 하단을 의미한다. 하지만 바운딩 박스의 높이와 너비는 셀 경계를 넘을 수 있다.

 

격자 셀마다 두 개의 바운딩 박스를 출력한다. 이를 통해 두 객체가 너무 가까이 있어서 바운딩 박스 중심이 같은 셀 안에 놓인 경우를 처리할 수 있다. 바운딩 박스마다 객체성 점수가 제공된다.

 

격자 셀에 대한 클래스 확률 분포를 출력한다. 

---

14.11 객체 추정

가장 널리 사용되는 객체 추적 시스템은 DeepSORT이다. 

---

14.12 시맨틱 분할

픽셀 수준으로 객체의 위치를 찾는 방법이다.

각 픽셀은 픽셀이 속한 객체의 클래스로 분류된다.

이 작업에서 가장 어려운 점은 이미지가 일반적인 CNN을 통과할 때 점진적으로 위치 정보를 잃는 것에 있다. (1 이상의 스트라이드를 사용하는 층 때문이다.)

 

해상도를 늘리는 업샘플링 층을 추가한다.

 

이중 선형 보간은 이미지 사이즈를 4배나 8배로 늘리는 데 적합하다. 

 

전치 합성곱 층을 사용하는 방법도 있다. 

이미지에 0으로 채워진 빈 행과 열을 삽입하여 이미지를 늘린 다음 일반적인 합성곱을 수행한다.

이를 부분 스트라이드로 사용하는 일반 합성곱으로 생각하는 경우도 있다. 

전치 합성곱 층은 선형 보간에 가까운 작업을 수행하도록 초기화될 수 있지만 훈련되는 층이기 때문에 훈련 과정에서 성능이 더 나빠질 수 있다. (Conv2DTranspose 층)

 

정확도 개선을 위해 아래쪽 층에서부터 스킵 연결을 추가한다.

원본 이미지보다 더 크게 업샘플링하는 것도 가능하며 초해상도라고 부른다.