keras BatchNormalization

Contributors

하헌진님, 흑염룡님, 머린이왕자님

  • CNN에서 batch normalization은 Convolution layer를 따라다닙니다.
  • 배치 정규화batch normalization는 그레이디언트 소실gradient vanishing과 폭주exploding 문제를 해결하기 위해 제안되었습니다.
  • 본 글에서는 배치 정규화의 이론적 내용을 다루지 않습니다.
  • tensorflow에 탑재된 keras의 BatchNormalization()이 어떤 결과를 만들어내는지에 집중합니다.

Sergey Ioffe, Christian Szegedy, “Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift”, ICML2015
tf.keras.layers.BatchNormalization

1. 예제 데이터 가져오기

  • 실제 상황에서는 많은 이미지를 학습시키겠지만, 3장으로 테스트해봅니다.
  • 입력 이미지와 히스토그램의 분포 변화를 그려봅니다.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    %matplotlib inline

    import tensorflow as tf
    from tensorflow.keras import layers

    import numpy as np
    import matplotlib.pyplot as plt
    import seaborn as sns

    img0 = plt.imread("./4-bn_0.jpg")
    img1 = plt.imread("./4-bn_1.jpg")
    img2 = plt.imread("./4-bn_2.jpg")
  • 불러온 이미지를 numpy vector로 만들어 줍니다.
  • 하나의 numpy array에 이미지를 모두 탑재합니다.
    1
    2
    3
    4
    5
    imgs = np.zeros((3, ) + img0.shape)
    imgs[0] = img0/255.0
    imgs[1] = img1/255.0
    imgs[2] = img2/255.0
    print(img0.shape)
    • 실행결과 : 256 x 256 크기의 3 channel image입니다.
      1
      (256, 256, 3)
  • 이미지를 눈으로 확인합니다.
  • 앞으로 자주 사용할 기능이니 figure를 리턴하는 함수로 만듭니다.
  • 연산을 거친 이미지가 그림으로 출력되기 어려운 범위로 환산될 것을 대비하여 이미지 minmax scaling을 미리 수행합니다.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    def plot_img(imgs):

    # 이미지 minmax scaling
    if imgs.min() < 0:
    imgs = imgs - imgs.min()
    if imgs.max() > 1:
    imgs = imgs/imgs.max()

    # 시각화
    fig, axs = plt.subplots(ncols=len(imgs), figsize=(3*len(imgs), 3))
    for img, ax in zip(imgs, axs):
    ax.imshow(img)

    fig.tight_layout()
    return fig

    # 데이터 시각화
    fig = plot_img(imgs)

2. 데이터 분포 확인하기

  • 데이터의 분포를 그림으로 그려서 확인합니다.
  • 컬러 이미지이므로 R, G, B 세 개의 채널이 있습니다.
  • 세 채널을 각기 빨강, 녹색, 파랑의 밀도함수로 표현합니다.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    def plot_kde(imgs, symmetry=False):

    # 시각화
    fig, axs = plt.subplots(ncols=len(imgs), figsize=(3*len(imgs), 3), sharex=True)

    for img, ax in zip(imgs, axs):
    channel = [0, 1, 2]
    color = ["r", "g", "b"]
    # R, G, B 채널 분포 시각화.
    # 오해가 발생하지 않도록 실제 데이터 범위에만 분포 시각화
    [sns.kdeplot(img[:,:,ch].flatten(), color=c, fill=True, ax=ax, cut=0) for ch, c in zip(channel, color)]

    # x축 범위 설정.
    # 필요시 x축을 0 중심으로 대칭이 되도록 설정할 수 있도록.
    xlim = ax.get_xlim()

    if symmetry==True:
    xlim = [-max(abs(xlim)), max(abs(xlim))]
    axs[0].set_xlim(xlim)

    fig.tight_layout()

    # 나중에 분포를 겹쳐 그리기 위해 fig 외에도 axes를 함께 리턴합니다.
    return fig, axs

    # 데이터 분포 시각화
    fig, axs = plot_kde(imgs)

3. Batch Normalization 적용 (1) 직접

  • 앞선 글에서 Conv2D만 따로 적용했습니다.
  • 이번에도 학습과정 없이 BatchNormalization()만 적용해 보겠습니다.
    1
    2
    3
    4
    5
    6
    imgs_tensor = tf.convert_to_tensor(imgs, dtype="float32")
    bn0 = layers.BatchNormalization(trainable=True)(imgs_tensor)
    bn0_numpy = bn0.numpy()

    fig1 = plot_img(bn0_numpy)
    fig2, _ = plot_kde(bn0_numpy)


  • 바뀐 것이 없습니다.
  • Batch Normalization은 Conv2D와 달리 학습 과정에서 데이터의 분포를 파악하여 적용하도록 설계되어 있기 때문에 이런 방식으로는 작동하지 않습니다.

4. Batch Normalization 적용 (2) 학습

  • 학습을 위한 최소한의 모델을 만듭니다.
  • BatchNormalization 레이어 외에는 아무것도 없습니다.
    1
    2
    3
    4
    5
    6
    from tensorflow.keras.models import Sequential

    model = Sequential([
    layers.BatchNormalization()
    ])
    model.compile()
  • 모델에 데이터를 투입하여 학습을 시킵니다.
  • 이 때, numpy array를 텐서로 변환하여 입력해야 합니다.
    1
    bn1 = model(imgs_tensor, training=True)
  • 잘 적용되었을까요? 확인합시다.
  • 다시 numpy array로 바꾸어서 이미지와 분포를 그려봅니다.
    1
    2
    3
    4
    bn1_numpy = bn1.numpy()

    fig1 = plot_img(bn1_numpy)
    fig2, _ = plot_kde(bn1_numpy)


  • Batch Normalization 이전과 이후를 나란히 놓아봅시다.

    Batch Normalization 이전과 이후 비교

  • 원본에 비해 색이 흐려진 것이 느껴집니다.

  • 이미지는 데이터를 그림으로 표현하기 위해 minmax scaling이 된 것입니다.

  • 실제 데이터의 분포는 아래에 있는 밀도함수를 통해 알 수 있습니다.
  • 원본에서 01 사이에 있던 값의 분포가 -22 사이로 변환되었습니다.
  • RGB 채널이 각기 독립적으로 normalization 되었습니다.

※ CNN에서 Batch Normalization은 대개 Convolution layer와 activation layer 사이에 위치합니다

  • Convolution을 거친 이미지는 Batch Normalization에 의해 고르게 분포됩니다.
  • 잘못된 초기화로 인해 학습이 어려워지는 문제를 해결할 수 있습니다.
  • 결과적으로 학습이 안정적으로 빠르게 이루어집니다.

※(추가) 위 그림이 BN효과를 오해할 소지가 있다고 생각되어 수정했습니다.

4. 보너스 - toy model

  • Batch Normalization은 데이터의 평균을 0, 분산을 1로 조정합니다.
  • 간단한 예제 데이터를 통해서 정말 그런지 살펴봅니다.
  • numpy array 형태의 예제 데이터를 만듭니다.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    # 예제 데이터 생성
    ex_img0 = np.random.normal(loc=-0.5, scale=0.01, size=256*256*3).reshape((256, 256, 3))
    ex_img1 = np.random.normal(loc=0.5, scale=0.01, size=256*256*3).reshape((256, 256, 3))
    ex_img2 = np.random.normal(loc=-0.5, scale=0.01, size=256*256*3).reshape((256, 256, 3))

    # 예제 데이터 vectorization
    ex_imgs = np.zeros((3, ) + ex_img0.shape)
    ex_imgs[0] = ex_img0
    ex_imgs[1] = ex_img1
    ex_imgs[2] = ex_img2

    # 데이터 시각화
    fig1 = plot_img(ex_imgs)
    fig2, _ = plot_kde(ex_imgs)


  • 평균이 각기 -0.5, 0.5, -0.5이고 표준편차가 0.01인 데이터가 만들어졌습니다.
    1
    print(ex_img0.var())
    • 실행결과 : 분산이 0.0001, 즉 표준편차는 0.01 맞습니다.
      1
      0.00010004582097558264
  • Batch Normalization을 적용합니다.
  • 데이터를 텐서로 만들어 적용하고, 시각화를 위해 다시 numpy로 변환합니다.
    1
    2
    3
    ex_imgs_tensor = tf.convert_to_tensor(ex_imgs, dtype="float32")
    ex_bn1 = model(ex_imgs_tensor, training=True)
    ex_bn1_numpy = ex_bn1.numpy()
  • 변환 결과를 그림으로 확인합니다.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    from matplotlib import patches

    fig1 = plot_img(ex_bn1_numpy)

    fig2, axs = plot_kde(ex_bn1_numpy, symmetry=True)
    for ax, ex_img in zip(axs, ex_imgs):
    sns.kdeplot(ex_img.flatten(), ax=ax, color="gray")

    Rectangle0 = patches.Rectangle((0.45, 0.9), 0.12, 0.05, color="lightgray", transform=axs[0].transAxes)
    axs[0].add_patch(Rectangle0)
    axs[0].text(0.6, 0.9, "before BN", fontdict={"fontsize":12, "color":"k"}, transform=axs[0].transAxes)
    Rectangle1 = patches.Rectangle((0.45, 0.8), 0.12, 0.05, color="navy", transform=axs[0].transAxes)
    axs[0].add_patch(Rectangle1)
    axs[0].text(0.6, 0.8, "after BN", fontdict={"fontsize":12, "color":"k"}, transform=axs[0].transAxes)


  • 그림으로 봐서는 모르겠습니다. minmax scaling이 적용되었기 때문입니다.
  • 그러나 분포를 보면, -0.5와 0.5에 분포했던 데이터가 각기 -1과 1 방향으로 이동한 것을 알 수 있습니다.
  • 정확한 값을 추측해봅시다.
    • -0.5, 0.5, -0.5의 평균은 $$\frac{-1}{6}$$, 표준편차는 $$\frac{\sqrt{2}}{3}$$입니다.
    • 따라서 -0.5, 0.5, -0.5의 Batch Normalization 결과는 $$\frac{-1}{\sqrt{2}}, \frac{2}{\sqrt{2}}, \frac{-1}{\sqrt{2}}$$가 될 것입니다.
    • 정말 그런지 확인해봅시다.
  • 평균값을 확인합니다.
    1
    print([ex_bn1_numpy[i].mean() for i in range(3)])
    • 실행결과 : $$\frac{-1}{\sqrt{2}}, \frac{2}{\sqrt{2}}, \frac{-1}{\sqrt{2}}$$입니다.
      1
      [-0.7053814, 1.4107242, -0.70534563]
  • mini-batch의 평균과 variance를 구합니다.
  • model의 layer에 데이터가 저장되어 있습니다.
    1
    2
    3
    4
    5
    mean = model.layers[0].variables[2].numpy()
    var = model.layers[0].variables[3].numpy()

    print(mean, mean.mean())
    print(var, var.mean())
    • 실행결과 : 0에 가까운 평균과 1에 가까운 분산이 출력되었습니다.
      1
      2
      [0.00435958 0.00288465 0.00303697] 0.0034270668
      [0.9828158 0.983015 0.9831719] 0.98300093


도움이 되셨나요?

카페인을 투입하시면 다음 포스팅으로 변환됩니다

Share