batchnorm_layer

Batch Normalization 이란?

Paper : https://arxiv.org/abs/1502.03167

Gradient Vanishing, Gradient Exploding 문제점
internal covariate shift : weight의 변화가 중첩되어 가중되는 크기 변화가 크다는 문제점
- careful initialization : Difficult
- small learning rate : Slow

위에 문제를 해결하기 위한 하나의 방법 입니다.

보통 internal covariate shift를 줄이기 위한 대표적인 방법은 각 layer의 입력에 whitening을 하는 것 입니다. 여기에서 whitening 이란 평균 0 분산 1로 바꾸어 주는 것(정규화)을 말합니다. 하지만 이러한 연산은 문제가 있습니다.

bias의 영향이 무시 됩니다.

만약 $y = WX + b$ 연산을 한 뒤에 정규화하기 위해서 평균을 빼주는 경우 $\hat{y} = y - mean(y)$ bias $b$ 의 영향이 사라지게 됩니다.(bias는 고정 스칼라 값이기 때문에 평균을 구해도 같은 값이 나옵니다.)

비선형성이 없어질 수 있습니다.

만약 sigmoid를 통과하는 경우 대부분의 입력값은 sigmoid의 중간 부분에 속합니다. sigmoid에서 중간은 선형이기 때문에 비선형성이 사라질 수 있다는 것입니다.

이러한 문제를 해결하기 위해 batch Normalization이 나왔습니다.

$m$ : mini-batch의 크기
$\mu$ : mean
$\sigma$ : std
$\gamma$ : scale
$\beta$ : shifts
$\gamma, \beta$ 는 학습 가능한 파라미터 입니다. 이것이 비선형성을 완화시키기 위한 파라미터 입니다.

배치 정규화는 학습 하는 경우에는 미니 배치의 평균과 분산을 구할 수 있지만 추론을 하는 경우는 미니 배치가 없기 때문에 학습 하는 동안 계산 된 이동 평균을 사용 합니다.

이동 평균 : 각 미니 배치 평균의 평균
이동 분산 : 각 미니 배치 분산의 평균 * m/(m-1) [Bessel’s Correction]

CNN의 경우 bias의 역할을 $\beta$ 가 대신 하기 때문에 bias를 제거합니다. 그리고 컨볼루션 연산을 통해 출력되는 특징 맵으로 각 채널마다 평균과 분산을 계산하고 $\gamma, \beta$ 를 만듭니다. 즉, 채널의 개수 만큼 $\gamma, \beta$ 가 생겨납니다.

장점

internal covariate shift 문제를 해결한다.
learning rate를 크게 해도 된다.
신중하게 초기값을 정할 필요가 없다.
dropout을 대체 할 수 있다.

forward_batchnorm_layer

void forward_batchnorm_layer(layer l, network net)
{
    if(l.type == BATCHNORM) copy_cpu(l.outputs*l.batch, net.input, 1, l.output, 1);
    copy_cpu(l.outputs*l.batch, l.output, 1, l.x, 1);
    if(net.train){
        mean_cpu(l.output, l.batch, l.out_c, l.out_h*l.out_w, l.mean);
        variance_cpu(l.output, l.mean, l.batch, l.out_c, l.out_h*l.out_w, l.variance);

        scal_cpu(l.out_c, .99, l.rolling_mean, 1);
        axpy_cpu(l.out_c, .01, l.mean, 1, l.rolling_mean, 1);
        scal_cpu(l.out_c, .99, l.rolling_variance, 1);
        axpy_cpu(l.out_c, .01, l.variance, 1, l.rolling_variance, 1);

        normalize_cpu(l.output, l.mean, l.variance, l.batch, l.out_c, l.out_h*l.out_w);   
        copy_cpu(l.outputs*l.batch, l.output, 1, l.x_norm, 1);
    } else {
        normalize_cpu(l.output, l.rolling_mean, l.rolling_variance, l.batch, l.out_c, l.out_h*l.out_w);
    }
    scale_bias(l.output, l.scales, l.batch, l.out_c, l.out_h*l.out_w);
    add_bias(l.output, l.biases, l.batch, l.out_c, l.out_h*l.out_w);
}

함수 이름: forward_batchnorm_layer

입력:

l: layer 구조체
net: network 구조체

동작:

Batch normalization 레이어를 수행합니다.

설명:

이 함수는 입력 데이터에 대해 Batch normalization을 수행합니다. 입력으로는 layer 구조체와 network 구조체가 필요합니다.
함수는 입력 데이터를 복사한 후, 학습 모드와 추론 모드를 구분하여 처리합니다. 학습 모드에서는 현재 배치에 대한 평균과 분산을 계산하고, 이를 사용하여 입력 데이터를 정규화합니다. 그 다음, 정규화된 데이터에 스케일과 바이어스를 적용합니다. 스케일과 바이어스는 layer 구조체 내의 scales 및 biases 필드에서 가져옵니다.
반면, 추론 모드에서는 배치에 대한 이동 평균과 이동 분산을 사용하여 입력 데이터를 정규화합니다. 이동 평균과 이동 분산은 layer 구조체 내의 rolling_mean 및 rolling_variance 필드에서 가져옵니다.
결과적으로, Batch normalization은 입력 데이터를 정규화하여 모델 학습을 안정화하고, 훨씬 빠르게 수렴하도록 도와줍니다.

backward_batchnorm_layer

void backward_batchnorm_layer(layer l, network net)
{
    if(!net.train){
        l.mean = l.rolling_mean;
        l.variance = l.rolling_variance;
    }
    backward_bias(l.bias_updates, l.delta, l.batch, l.out_c, l.out_w*l.out_h);
    backward_scale_cpu(l.x_norm, l.delta, l.batch, l.out_c, l.out_w*l.out_h, l.scale_updates);

    scale_bias(l.delta, l.scales, l.batch, l.out_c, l.out_h*l.out_w);

    mean_delta_cpu(l.delta, l.variance, l.batch, l.out_c, l.out_w*l.out_h, l.mean_delta);
    variance_delta_cpu(l.x, l.delta, l.mean, l.variance, l.batch, l.out_c, l.out_w*l.out_h, l.variance_delta);
    normalize_delta_cpu(l.x, l.mean, l.variance, l.mean_delta, l.variance_delta, l.batch, l.out_c, l.out_w*l.out_h, l.delta);
    if(l.type == BATCHNORM) copy_cpu(l.outputs*l.batch, l.delta, 1, net.delta, 1);
}

함수 이름: backward_batchnorm_layer

입력:

l: layer 구조체
net: network 구조체

동작:

net.train이 false이면 현재 층의 rolling mean과 rolling variance로 l.mean과 l.variance를 대체한다.
bias 업데이트와 scale 업데이트를 수행한다.
delta를 scale로 곱하고 bias를 더해준다.
delta에 대한 mean delta를 계산한다.
delta에 대한 variance delta를 계산한다.
delta를 정규화한다.
만약 l.type이 BATCHNORM이면 delta를 net.delta로 복사한다.

설명:

이 함수는 배치 정규화 층의 역전파(backpropagation)를 수행한다. 배치 정규화 층의 역전파는 순전파(forward propagation)와는 다르게 여러 단계로 구성되어 있어 복잡하다. 이 함수는 이러한 단계들을 수행하여 역전파를 구현한다.
우선, net.train이 false인 경우 현재 층의 rolling mean과 rolling variance로 l.mean과 l.variance를 대체한다. rolling mean과 rolling variance는 현재 mini-batch 이전의 모든 데이터셋에서 계산된 평균과 분산을 저장하고 있다. 따라서 이전 데이터셋의 통계량을 사용하여 현재 mini-batch의 정규화를 수행한다.
다음으로, bias 업데이트와 scale 업데이트를 수행한다. 이전 층에서 업데이트한 bias와 scale을 사용하여 현재 층의 bias와 scale을 업데이트한다.
그 후, delta를 scale로 곱하고 bias를 더해준다. 이는 순전파에서 delta를 정규화하기 전에 수행한 scale과 bias의 연산을 역전파하는 것이다.
그 다음, delta에 대한 mean delta를 계산한다. 이는 순전파에서 정규화된 입력 값에 대한 delta를 계산하기 위해 사용한 mean을 역전파하는 것이다.
delta에 대한 variance delta를 계산한 후, 이를 사용하여 delta를 정규화한다. 이는 순전파에서 정규화된 입력 값에 대한 delta를 계산하기 위해 사용한 variance를 역전파하는 것이다.
마지막으로, 만약 l.type이 BATCHNORM인 경우 delta를 net.delta로 복사한다. 이는 이전 층의 delta에 대한 역전파를 위한 작업이다.

make_batchnorm_layer

layer make_batchnorm_layer(int batch, int w, int h, int c)
{
    fprintf(stderr, "Batch Normalization Layer: %d x %d x %d image\n", w,h,c);
    layer l = {0};
    l.type = BATCHNORM;
    l.batch = batch;
    l.h = l.out_h = h;
    l.w = l.out_w = w;
    l.c = l.out_c = c;
    l.output = calloc(h * w * c * batch, sizeof(float));
    l.delta  = calloc(h * w * c * batch, sizeof(float));
    l.inputs = w*h*c;
    l.outputs = l.inputs;

    l.scales = calloc(c, sizeof(float));
    l.scale_updates = calloc(c, sizeof(float));
    l.biases = calloc(c, sizeof(float));
    l.bias_updates = calloc(c, sizeof(float));
    int i;
    for(i = 0; i < c; ++i){
        l.scales[i] = 1;
    }

    l.mean = calloc(c, sizeof(float));
    l.variance = calloc(c, sizeof(float));

    l.rolling_mean = calloc(c, sizeof(float));
    l.rolling_variance = calloc(c, sizeof(float));

    l.forward = forward_batchnorm_layer;
    l.backward = backward_batchnorm_layer;

    return l;
}

함수 이름: make_batchnorm_layer

입력:

batch: 배치 크기
w: 이미지 너비
h: 이미지 높이
c: 채널 수

동작:

배치 정규화 레이어를 생성하고 초기화합니다.
배치 정규화의 스케일과 바이어스 값을 1과 0으로 초기화하고, 평균과 분산, 그리고 롤링 평균과 롤링 분산 값을 0으로 초기화합니다.
입력과 출력의 크기를 설정하고, forward_batchnorm_layer와 backward_batchnorm_layer 함수를 설정합니다.

설명:

이 함수는 배치 정규화 레이어를 생성하고 초기화합니다.
배치 정규화 레이어는 인공 신경망에서 입력값을 정규화하는 레이어로, 입력값의 분포를 안정화하여 학습을 더욱 안정적으로 만듭니다. 이 함수에서는 배치 정규화 레이어를 생성하고 필요한 변수들을 초기화합니다.
입력값과 출력값의 크기는 인자로 받은 값에 따라 설정하며, 스케일, 바이어스, 평균, 분산 등의 변수도 초기화합니다. 이 함수에서는 초기 스케일 값을 1로, 바이어스 값을 0으로 설정합니다.
평균과 분산, 롤링 평균과 롤링 분산은 모두 0으로 초기화됩니다.
이 함수에서는 forward_batchnorm_layer와 backward_batchnorm_layer 함수를 설정하며, 이 함수를 통해 생성된 배치 정규화 레이어는 인공 신경망 모델의 구성 요소로 활용됩니다.

backward_scale_cpu

void backward_scale_cpu(float *x_norm, float *delta, int batch, int n, int size, float *scale_updates)
{
    int i,b,f;
    for(f = 0; f < n; ++f){
        float sum = 0;
        for(b = 0; b < batch; ++b){
            for(i = 0; i < size; ++i){
                int index = i + size*(f + n*b);
                sum += delta[index] * x_norm[index];
            }
        }
        scale_updates[f] += sum;
    }
}

함수 이름: backward_scale_cpu

입력:

x_norm: normalization된 입력값을 가리키는 포인터(float 배열)
delta: 출력값에 대한 손실의 미분값을 가리키는 포인터(float 배열)
batch: 미니배치 크기(int)
n: 필터 수(int)
size: 필터 크기(int)
scale_updates: 스케일 매개변수의 업데이트 값을 저장할 포인터(float 배열)

동작:

입력값을 normalization한 후, 출력값에 대한 손실의 미분값과 곱한 결과를 미니배치와 필터, 크기별로 합하여 스케일 매개변수의 업데이트 값을 계산합니다.

설명:

Convolutional Neural Network에서 Batch Normalization 계층에서 사용되는 함수 중 하나로, 스케일 매개변수의 업데이트 값을 계산하는 함수입니다.
스케일 매개변수는 정규화된 입력값에 대해 곱해지는 매개변수로, 업데이트는 이 매개변수가 손실을 줄이는 방향으로 조정됩니다.
이 함수는 backward propagation 단계에서 호출되며, 출력값에 대한 손실의 미분값과 normalization된 입력값의 곱을 미니배치와 필터, 크기별로 합하여 스케일 매개변수의 업데이트 값을 계산합니다.

mean_delta_cpu

void mean_delta_cpu(float *delta, float *variance, int batch, int filters, int spatial, float *mean_delta)
{

    int i,j,k;
    for(i = 0; i < filters; ++i){
        mean_delta[i] = 0;
        for (j = 0; j < batch; ++j) {
            for (k = 0; k < spatial; ++k) {
                int index = j*filters*spatial + i*spatial + k;
                mean_delta[i] += delta[index];
            }
        }
        mean_delta[i] *= (-1./sqrt(variance[i] + .00001f));
    }
}

함수 이름: mean_delta_cpu

입력:

delta: 이전 층의 델타 값 (float 형태의 1차원 배열)
variance: 현재 층의 분산 값 (float 형태의 1차원 배열)
batch: 배치 사이즈 (int)
filters: 필터 개수 (int)
spatial: 공간 차원의 크기 (int)
mean_delta: 현재 층의 평균 델타 값 (float 형태의 1차원 배열)

동작:

현재 층의 평균 델타 값을 계산하는 함수
각 필터별로 델타 값의 합을 구하고, 분산의 제곱근 값으로 나누어 평균 델타 값을 구함

설명:

mean_delta_cpu 함수는 Batch Normalization의 학습 과정 중 현재 층의 평균 델타 값을 계산하는 함수이다.
각 필터별로 델타 값의 합을 구한 후, 해당 필터의 분산 값의 제곱근으로 나누어 평균 델타 값을 계산한다.
이때 분산 값에 0으로 나누는 것을 방지하기 위해 작은 상수값(.00001f)을 더해준다.
계산된 평균 델타 값은 mean_delta 배열에 저장된다.

variance_delta_cpu

void  variance_delta_cpu(float *x, float *delta, float *mean, float *variance, int batch, int filters, int spatial, float *variance_delta)
{

    int i,j,k;
    for(i = 0; i < filters; ++i){
        variance_delta[i] = 0;
        for(j = 0; j < batch; ++j){
            for(k = 0; k < spatial; ++k){
                int index = j*filters*spatial + i*spatial + k;
                variance_delta[i] += delta[index]*(x[index] - mean[i]);
            }
        }
        variance_delta[i] *= -.5 * pow(variance[i] + .00001f, (float)(-3./2.));
    }
}

함수 이름: variance_delta_cpu

입력:

x: 현재 층의 입력
delta: 현재 층의 델타
mean: 현재 층의 평균
variance: 현재 층의 분산
batch: 배치 크기
filters: 필터 개수
spatial: 공간 크기
variance_delta: 분산 델타

동작:

현재 층의 분산 델타를 계산하는 함수입니다.
입력으로 현재 층의 입력(x), 델타(delta), 평균(mean), 분산(variance), 배치 크기(batch), 필터 개수(filters), 공간 크기(spatial)가 주어집니다.
각 필터별로 분산 델타를 계산하며, 이를 위해 각 배치에서 현재 필터와 공간 위치에 따른 인덱스를 계산합니다.
분산 델타는 delta와 (x-mean)의 곱의 합으로 계산되며, 이 값에 -(variance+0.00001f)^(3/2)를 곱한 값의 반대값을 저장합니다.

설명:

배치 정규화(batch normalization)에서는 각 층에서 입력(x)에 대한 평균(mean)과 분산(variance)을 계산합니다.
그리고 분산 델타(variance delta)는 이전 층의 출력값과 현재 층의 델타를 이용하여 계산됩니다.
이 함수는 분산 델타를 계산하기 위한 함수 중 하나로, 현재 층의 입력, 델타, 평균, 분산을 이용하여 분산 델타를 계산합니다.

normalize_delta_cpu

void normalize_delta_cpu(float *x, float *mean, float *variance, float *mean_delta, float *variance_delta, int batch, int filters, int spatial, float *delta)
{
    int f, j, k;
    for(j = 0; j < batch; ++j){
        for(f = 0; f < filters; ++f){
            for(k = 0; k < spatial; ++k){
                int index = j*filters*spatial + f*spatial + k;
                delta[index] = delta[index] * 1./(sqrt(variance[f] + .00001f)) + variance_delta[f] * 2. * (x[index] - mean[f]) / (spatial * batch) + mean_delta[f]/(spatial*batch);
            }
        }
    }
}

함수 이름: normalize_delta_cpu

입력:

float *x: 입력값 포인터
float *mean: 평균값 포인터
float *variance: 분산값 포인터
float *mean_delta: 평균값 변화량 포인터
float *variance_delta: 분산값 변화량 포인터
int batch: 배치 크기
int filters: 필터 개수
int spatial: 공간 크기
float *delta: 델타값 포인터

동작:

입력값 x, 평균값 mean, 분산값 variance, 평균값 변화량 mean_delta, 분산값 변화량 variance_delta, 배치 크기 batch, 필터 개수 filters, 공간 크기 spatial, 델타값 delta를 받아서 델타값 delta를 정규화(normalize)한다.
정규화를 하기 위해 델타값 delta를 평균(mean)과 분산(variance)을 이용하여 표준화(standardize)한다.
또한, 평균값 변화량 mean_delta, 분산값 변화량 variance_delta를 이용하여 평균과 분산의 변화량을 추가로 반영한다.

설명:

입력값과 델타값은 모두 (batch * filters * spatial) 크기의 1차원 배열로 표현된다.
이 함수는 CPU에서 동작하며, GPU에서 동작하는 버전도 존재한다.
일반적으로 딥러닝에서 입력값을 정규화하는 것은 학습의 안정성과 성능 향상을 도모하기 위한 방법 중 하나이다.
입력값 x를 평균 mean과 분산 variance를 이용하여 표준화한 후, 델타값 delta에 다시 곱해줌으로써 입력값을 정규화한다.
평균값 변화량 mean_delta와 분산값 변화량 variance_delta는 이전 배치에서의 값들을 고려하여 새로운 배치에서의 평균과 분산이 어떻게 변화하는지 추정하기 위한 값이다.

Previousavgpool Nextblas

Last updated 1 year ago