배치 크기와 기울기 누적

신경망은 자료 전체를 한꺼번에 보지 않고 몇 개씩 묶어서 배웁니다. 배치가 작으면 스텝(step)이 흔들리고, 크면 메모리를 먹습니다. 같은 30스텝을 배치 1, 8, 전체로 걸어 보고, 흔들림이 왜 σ ÷ √B 로 줄어드는지 한 단계씩 봅니다.

한 줄 답. 배치 크기 B 는 가중치를 한 번 고칠 때 보는 예제의 수입니다. 배치가 클수록 기울기(그래디언트)의 흔들림이 σ ÷ √B 로 줄지만(4배 키워야 절반), 메모리는 배치에 비례해 늘고 한 에폭의 스텝 수는 줄어 학습률을 같이 맞춰야 합니다. 메모리가 모자라면 작은 배치 k 번의 기울기를 모아 한 번 고치는 기울기 누적으로 배치 k 배와 같은 기울기를 얻습니다.

위의 단추로 배치 크기를 고르세요. 점 64개 (x, y) 에 직선 ŷ = w·x + b 를 맞추는 작게 줄인 본보기입니다. 손실은 예제마다 ½(ŷ − y)² 의 평균이고, 학습률 0.3 으로 30스텝 걷습니다. 에폭마다 예제를 섞고 앞에서부터 B 개씩 씁니다. 자료와 섞는 순서는 고정 시드(seed)로 지어내 쪽을 열 때마다 같습니다. 진짜 신경망은 가중치가 훨씬 많고 손실의 그릇도 이렇게 매끈한 타원이 아니지만, 배치가 작을수록 스텝이 흔들리는 것은 같습니다.

1. 배치, 에폭, 스텝

배치 기울기   g_B = (g₁ + g₂ + … + g_B) ÷ B     예제마다의 기울기를 평균 낸다
한 스텝       θ ← θ − η · g_B                    η 는 학습률, θ 는 가중치들

스텝 하나는 경사 하강법과 같고, 기울기를 전체 자료가 아니라 배치로 낸다는 것만 다릅니다. 기울기를 내는 법은 역전파 쪽에 있습니다. 위 실험은 N = 64 입니다. 배치 8 이면 한 에폭이 64 ÷ 8 = 8 스텝이라 30스텝은 예제 240개, 3.75 에폭입니다. 배치 1 은 30스텝에 예제 30개만 보고(0.47 에폭), 전체 배치는 스텝마다 64개를 다 봅니다(30 에폭).

한 에폭의 스텝 수 = ⌈N ÷ B⌉
에폭 수           = 본 예제 수 ÷ N = 스텝 × B ÷ N

칸 하나가 예제 하나이고, 숫자는 예제 번호입니다. 옅은 초록과 옅은 파랑이 B 칸씩 번갈아 배치를 나눕니다. 진한 파랑에 괄호와 「스텝 n」이 붙은 칸이 이번 스텝의 배치이고, 회색은 이번 에폭에서 이미 쓴 칸입니다. 섞는 순서가 맨 위 실험과 같아서 같은 스텝에 같은 예제를 씁니다. 배치 단추도 맨 위 실험과 같이 바뀝니다.

해 볼 것. ① 처음(배치 8)은 섞기 전입니다. 「다음」: 칸이 섞여 자리를 옮기고, 맨 앞 8칸(예제 52, 20, 63, 55, 23, 18, 13, 48)으로 스텝 1 을 걷습니다. 본 예제 8, 에폭 0.13. ② 「다음」을 7번 더 누르면 스텝 8 에서 띠 끝에 닿습니다. 본 예제 64, 에폭 1. ③ 「다음」: 다시 섞입니다. 예제 1 이 띠의 64번째에서 50번째로 옮기고, 스텝 9 의 배치는 예제 13, 4, 30, 2, 57, 25, 5, 11 입니다. ④ 스텝 30 까지 가면 본 예제 240, 에폭 3.75 로 위 문장과 같습니다. 그 자리에서 「배치 1」을 누르면 예제 30개, 0.47 에폭, 「전체(64)」는 1920개, 30 에폭입니다.

배치를 꺼내 기울기를 내고 한 스텝 고치는 일을 에폭마다 되풀이하는 고리 전체는 학습 루프 쪽에 있습니다.

2. 작은 배치는 흔들리고, 큰 배치는 메모리를 먹는다

흔들림. 배치 기울기는 전체 기울기를 몇 개의 예제로 어림한 값입니다. 예제를 무작위로 뽑으면 평균적으로는 전체 기울기와 같지만, 뽑을 때마다 조금씩 틀립니다. 배치가 작을수록 많이 틀려서 스텝이 이리저리 흔들립니다. 바닥 근처에서도 예제 하나하나는 저마다 다른 쪽을 가리키므로, 작은 배치는 바닥에 멈추지 못하고 주변을 맴돕니다.

메모리. 역전파는 앞으로 계산하며 나온 중간값(활성값)을 예제마다 저장해 두었다가 기울기를 냅니다. 그래서 배치를 두 배로 하면 활성값의 메모리도 두 배입니다. 가중치와 옵티마이저가 들고 있는 값은 배치와 상관없습니다.

속도. GPU 는 여러 예제를 한꺼번에 계산합니다. 배치가 너무 작으면 GPU 가 놀고, GPU 가 다 찰 때까지는 배치를 키워도 한 스텝에 드는 시간이 배치만큼 늘지 않습니다. 대신 한 에폭의 스텝 수가 줄어듭니다.

해 볼 것. ① 처음(배치 8): 30스텝 뒤 바닥까지 거리 0.07, 지나온 길 7.2 입니다. ② 「배치 1」: 지나온 길이 16.15 로 두 배가 넘고, 바닥 근처에서도 튀어 다녀 거리가 0.73 입니다. 예제는 30개만 썼습니다. ③ 「전체(64)」: 길 4.38 로 곧게 내려가 거리 0 입니다. 대신 스텝마다 64개, 모두 1920개를 계산했습니다. 같은 스텝 수라면 큰 배치가 곧지만, 같은 계산량이라면 작은 배치가 스텝을 훨씬 많이 걷습니다.

3. 식이 만들어지는 과정: 흔들림 = σ ÷ √B

실험 ① 의 출발점 (w, b) = (−1, −2) 에서 예제 64개의 기울기(w 쪽)를 하나씩 구합니다. 그리고 배치를 1000번 뽑아 배치 기울기가 얼마나 흔들리는지 잽니다. 흔들림은 표준편차로 잽니다. 여기서는 뽑은 예제를 다시 넣고 뽑습니다(복원 추출). 그래야 뽑은 값들이 서로 독립이라 식이 정확히 맞습니다.

  1. 예제 하나: σ. 예제 64개의 기울기는 평균 μ = −5.47, 표준편차 σ = 7.32 입니다. μ 가 전체 배치의 기울기입니다. 배치 1 은 이 가운데 하나를 뽑는 것이니 σ 만큼 흔들립니다. 값이 한쪽(음수)으로 길게 늘어져 있어도 괜찮습니다. 아래 계산은 분산만 씁니다.
  2. B 개를 더하면: √B · σ. 4개를 뽑아 더하면 가운데가 4μ 로 갑니다. 퍼짐은 4σ 가 아니라 √4 · σ = 14.63 입니다(잰 값 14.42). 까닭: 서로 독립인 값을 더하면 분산이 더해집니다. Var(g₁ + … + g_B) = B · σ². 한 예제가 크게 틀려도 다른 예제가 반대로 틀려 일부 지워지기 때문에, 표준편차는 B 배가 아니라 √B 배만 커집니다.
  3. B 로 나누면: √B · σ ÷ B = σ ÷ √B. 배치 기울기는 합이 아니라 평균이라 B 로 나눕니다. 가운데는 μ 로 돌아오고 퍼짐은 7.32 ÷ √4 = 3.66 이 됩니다(잰 값 3.6). 까닭: 평균을 쓰면 배치 크기와 상관없이 기울기의 크기가 같은 눈금에 있어 학습률을 따로 맞추기 쉽고, 흔들림만 √B 로 줄어듭니다. 계산은 B 배인데 흔들림은 √B 분의 1 이라, 배치를 4배 키워야 흔들림이 절반입니다.
  4. 기울기 누적: σ ÷ √B, B = b × k. 메모리에 2개만 들어간다면 2개씩(b = 2) 두 번(k = 2) 기울기를 내 평균을 낸 뒤 한 번 고칩니다. ((g₁ + g₂) ÷ 2 + (g₃ + g₄) ÷ 2) ÷ 2 = (g₁ + g₂ + g₃ + g₄) ÷ 4 라서 배치 4 의 기울기와 같은 숫자입니다. 그래서 흔들림 식의 B 는 마이크로배치 크기 b 가 아니라 b × k 입니다.

실제 학습처럼 예제를 섞어 겹치지 않게 뽑으면 흔들림은 이보다 조금 더 작고, 배치가 자료 전체가 되면 0 이 됩니다(실험 ① 의 전체 배치). 자료가 배치보다 훨씬 많으면 두 방식의 차이는 작습니다.

해 볼 것. ① 처음 단계에서 아래 막대는 위의 점들처럼 퍼집니다(σ = 7.32, 잰 값 6.87). ② 「다음」: 막대가 왼쪽 4μ 쪽으로 옮겨 가고 파란 띠가 ±14.63 으로 두 배가 됩니다. 눈금 간격이 위와 같아 넓어진 것이 그대로 보입니다. ③ 「다음」: 띠가 ±3.66 으로 처음의 절반입니다. 설명 줄에 B = 8 은 2.7(식 2.59), B = 16 은 1.83(식 1.83)이 나옵니다. ④ 「다음」: 흐린 막대(마이크로배치 하나, ±5.17)보다 진한 막대가 좁고 ③ 과 똑같습니다. 같은 예제로 낸 배치 4 의 기울기와 가장 큰 차이가 0 입니다.

4. 손으로 풀어 보기

예제 넷의 기울기가 1, 3, 5, 7 이라고 합시다.

  1. 전체 배치. (1 + 3 + 5 + 7) ÷ 4 = 4.
  2. 메모리에 둘만 들어간다. 마이크로배치 [1, 3] 의 평균 2, [5, 7] 의 평균 6.
  3. 누적. (2 + 6) ÷ 2 = 4. 전체 배치와 같습니다. 코드에서는 손실을 k = 2 로 나눠 두고 기울기를 더합니다: 2 ÷ 2 + 6 ÷ 2 = 4.
  4. 나누기를 잊으면. 2 + 6 = 8. 기울기가 두 배라, 학습률을 몰래 두 배로 올린 것과 같은 스텝이 됩니다.
  5. 크기가 다른 마이크로배치. [1, 3] 과 [5] 로 나누면 평균 2 와 5 의 단순 평균은 3.5 인데, 세 값의 평균은 (1 + 3 + 5) ÷ 3 = 3 입니다. 개수로 가중해야 맞습니다: (2 × 2 + 5 × 1) ÷ 3 = 3.
  6. 흔들림. 넷의 분산은 ((−3)² + (−1)² + 1² + 3²) ÷ 4 = 20 ÷ 4 = 5, σ = √5 ≈ 2.24. 복원 추출로 배치 4 를 뽑으면 2.24 ÷ √4 = 1.12, 배치 16 이면 2.24 ÷ 4 = 0.56 만큼 흔들립니다.

에폭도 세어 봅니다. 자료 1000개를 배치 32 로 나누면 1000 ÷ 32 = 31.25 라 올려서 32스텝이고, 마지막 배치는 1000 − 31 × 32 = 8 개입니다. 마지막의 작은 배치를 버리는 설정(PyTorch DataLoader 의 drop_last)도 있습니다.

5. 꼭 알아야 할 성질

성질쉬운 말실험에서
배치 기울기의 평균은 전체 기울기무작위로 뽑으면 평균적으로 맞는 쪽을 가리킨다. 뽑을 때마다 틀리는 만큼이 흔들림이다② 의 주황 눈금이 늘 μ 에 있다
흔들림은 σ ÷ √B계산은 B 배, 흔들림은 √B 분의 1. 4배 키워야 절반이다② 의 ③ 단계
한 에폭은 ⌈N ÷ B⌉ 스텝배치를 키우면 같은 에폭에 걷는 스텝이 준다① 의 에폭 수
메모리는 배치에 비례활성값을 예제마다 저장한다. 가중치의 메모리는 그대로실험 밖
누적 k 번 = 배치 k 배같은 예제면 같은 기울기. 배치 정규화가 있으면 예외② 의 ④ 단계

6. 배치를 키우면 학습률도 같이 본다

7. 메모리가 모자랄 때: 기울기 누적

원하는 배치가 메모리에 들어가지 않으면, 들어가는 크기 b 로 k 번 순전파(forward pass)·역전파를 하며 기울기를 모으고, 모은 뒤에 한 번만 고칩니다. 이것이 기울기 누적이고, 한 번 고칠 때 본 예제 수 b × k 를 실효 배치 크기라고 부릅니다. GPU 여러 대에서 기울기를 평균 내며 학습하면 거기에 GPU 수가 더 곱해집니다.

# PyTorch: backward() 는 기울기를 .grad 에 더한다. 그래서 k 번 부른 뒤에 한 번 고친다
k = 4                                          # 모을 횟수. loader 의 배치 크기가 마이크로배치 b
optimizer.zero_grad()
for i, (x, y) in enumerate(loader):
    loss = loss_fn(model(x), y) / k             # k 로 나눠야 더한 것이 평균이 된다
    loss.backward()
    if (i + 1) % k == 0:
        optimizer.step()                        # 실효 배치 b × k 로 한 스텝
        optimizer.zero_grad()

혼합 정밀도도 메모리를 줄이는 다른 길입니다. 숫자를 32비트 대신 16비트로 계산해 활성값의 메모리를 줄이고, 가중치는 32비트 원본을 따로 두어 거기에 고칩니다. FP16 에서는 작은 기울기가 0 으로 사라지지 않게 손실에 큰 수를 곱했다가 나중에 나눕니다(손실 스케일링). 기울기 누적과 같이 쓸 수 있습니다.

8. 언제 무엇을 쓰나

선택지좋은 점나쁜 점쓰는 경우
작은 배치메모리가 적다. 한 에폭에 스텝이 많다. 흔들림이 과적합을 막는 쪽으로 작용하기도 한다스텝이 흔들려 작은 학습률이 필요할 수 있다. GPU 를 다 쓰지 못한다메모리가 빠듯할 때, 자료가 적을 때
큰 배치기울기가 정확하다. GPU 를 꽉 채워 한 에폭이 빨리 끝난다메모리를 많이 먹는다. 4배 키워도 흔들림은 절반뿐이다. 학습률과 워밍업을 다시 맞춰야 한다GPU 가 여럿이거나 넉넉할 때, 학습 시간을 줄이고 싶을 때
전체 배치흔들림이 0 이라 경로가 곧고 늘 같다자료가 크면 메모리에 안 들어간다. 한 스텝이 비싸다자료가 작은 고전 모델(로지스틱 회귀 같은)
기울기 누적메모리는 그대로 두고 큰 배치와 같은 기울기를 낸다시간은 줄지 않는다. 손실을 k 로 나눠야 한다. 배치 정규화는 작은 배치 통계다원하는 배치가 메모리에 안 들어갈 때(큰 모델의 미세 조정)
혼합 정밀도활성값 메모리가 줄고, 지원하는 GPU 에서는 빨라질 수 있다16비트는 표현 범위가 좁아 값이 넘치거나 0 이 될 수 있다. 손실 스케일링이 필요할 수 있다16비트 계산을 지원하는 GPU 에서, 누적과 같이

어디에 쓰나

자주 묻는 것

배치 크기는 2의 거듭제곱으로 해야 하나요?

꼭 그럴 필요는 없습니다. 교과서 『Deep Learning』은 GPU 에서 2의 거듭제곱 크기가 더 빨리 도는 경우가 많다고 적습니다. 빨라지는 것이지 학습 결과가 좋아지는 것은 아닙니다. 쓰는 장비에서 몇 가지 크기로 한 스텝의 시간을 재 보고 정합니다.

배치를 두 배로 늘리면 학습률도 두 배로 해야 하나요?

출발점으로는 그렇게 합니다. 배치를 k 배로 하면 학습률도 k 배로 하는 선형 스케일링 규칙이 있고, 처음 얼마 동안 학습률을 작게 시작해 서서히 올리는 워밍업을 같이 씁니다. 다만 학습률에는 발산하지 않는 상한이 있고, 배치가 아주 크면 이 규칙으로도 결과가 나빠진다는 보고가 있어 검증 손실을 보며 맞춥니다.

기울기 누적을 쓰면 큰 배치와 결과가 똑같나요?

기울기는 같습니다. 단, 마이크로배치마다 손실을 k 로 나눠 더하고, 마이크로배치의 크기가 같아야 합니다. 다른 점도 있습니다. 배치 정규화는 마이크로배치 안에서 평균과 분산을 내므로 작은 배치의 통계가 되고, 계산을 k 번 차례로 하니 걸리는 시간은 줄지 않습니다. 더하는 순서가 달라 끝자리 숫자가 아주 조금 다를 수 있습니다.

낱말

여기서 쓴 말책에서 부르는 말
한 번 고칠 때 보는 예제 묶음미니배치(mini-batch), 배치(batch)
묶음의 크기배치 크기(batch size)
가중치를 한 번 고치기스텝(step), 반복(iteration), 갱신(update)
자료 전체를 한 번 보기에폭(epoch)
배치로 걷는 경사 하강법미니배치 확률적 경사 하강법(minibatch SGD). 좁게는 배치 1 을 확률적 경사 하강법(SGD), 전체를 배치 경사 하강법(batch gradient descent)이라 한다
스텝의 크기학습률(learning rate, η)
배치 기울기의 흔들림 σ ÷ √B평균의 표준오차(standard error)
다시 넣고 뽑기복원 추출(sampling with replacement)
작은 배치 k 번을 모아 한 번 고치기기울기 누적(gradient accumulation). 작은 배치는 마이크로배치(micro-batch)
한 번 고칠 때 본 예제 수실효 배치 크기(effective batch size)
배치만큼 학습률 키우기선형 스케일링 규칙(linear scaling rule)
처음에 학습률을 서서히 올리기워밍업(warmup)
앞으로 계산하며 나온 중간값활성값(activation)
16비트와 32비트를 섞어 계산하기혼합 정밀도(mixed precision). 곱했다 나누기는 손실 스케일링(loss scaling)

출처

← 학습률 스케줄정답 표현 →