# Gradient 동기화

PyTorch의 distributed 모듈은 시스템 내 모든 GPU 간에 양방향 통신을 수행하여 동작합니다. 이 통신에는 시간이 소요되며, `ddp` 모듈을 사용할 경우 모든 프로세스가 서로의 상태를 인지하도록 하는 과정은 특정 트리거 포인트에서 발생합니다.

이러한 트리거 포인트는 PyTorch 모델, 구체적으로 `forward()` 및 `backward()` 메서드에 추가됩니다. 이는 모델이 `DistributedDataParallel`로 래핑될 때 발생합니다:
```python
import torch.nn as nn
from torch.nn.parallel import DistributedDataParallel

model = nn.Linear(10, 10)
ddp_model = DistributedDataParallel(model)
```
Accelerate에서는 [prepare()](/docs/accelerate/v1.16.0/ko/package_reference/accelerator#accelerate.Accelerator.prepare)를 호출하고 모델을 전달하면 이 변환이 자동으로 수행됩니다.

```diff
+ from accelerate import Accelerator
+ accelerator = Accelerator()
  import torch.nn as nn
- from torch.nn.parallel import DistributedDataParallel

  model = nn.Linear(10,10)
+ model = accelerator.prepare(model)
```

## 그라디언트 축적의 성능 저하

분산 환경에서 PyTorch 모델을 학습할 때 PyTorch가 모델의 `forward` 및 `backward` 메서드에 훅을 추가한다는 점을 이제 이해했습니다. 그렇다면 이것이 어떻게 코드의 실행 속도를 늦출 위험이 있을까요?

DDP(distributed data parallel)에서는 프로세스가 수행되고 실행되는 특정 순서가 특정 시점에 예상되며, 이러한 동작들도 대략 같은 시점에 발생해야 다음 단계로 진행할 수 있습니다.

가장 직접적인 예는 `optimizer.step()`을 통해 모델 매개변수를 업데이트하는 경우입니다. 그라디언트 축적이 없으면, 다음 데이터 배치로 넘어가기 전에 모델의 모든 인스턴스에서 그라디언트가 계산되고, 수집(collated)되며, 업데이트되어야 합니다. 그라디언트 축적을 수행할 때는 `n`개의 손실 그라디언트를 축적하고, `n`개의 배치에 도달할 때까지 `optimizer.step()`을 건너뜁니다. 모든 학습 프로세스는 `optimizer.step()`이 호출되는 시점에 동기화만 하면 되므로, 학습 단계에 대한 수정 없이도 이러한 불필요한 프로세스 간 통신이 상당한 성능 저하를 초래할 수 있습니다.

 이 오버헤드를 어떻게 피할 수 있을까요?

## 속도 저하 문제 해결

이러한 배치로 학습할 때 모델 파라미터 업데이트를 건너뛰므로, `optimizer.step()`이 실제로 호출되는 시점까지 그라디언트를 동기화할 필요가 없습니다. PyTorch는 이를 자동으로 감지할 수 없지만, DDP로 변환한 후 모델에 추가되는 [`no_sync`](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel.no_sync) 컨텍스트 매니저를 통해 이를 돕는 도구를 제공합니다.

이 컨텍스트 매니저 아래에서 PyTorch는 `.backward()`가 호출될 때 그라디언트 동기화를 건너뛰며, 이 컨텍스트 매니저 바깥에서 `.backward()`를 처음 호출할 때 동기화가 트리거됩니다. 아래 예시를 참조하세요:
```python
ddp_model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)

for index, batch in enumerate(dataloader):
    inputs, targets = batch
    # Trigger gradient synchronization on the last batch
    if index != (len(dataloader) - 1):
        with ddp_model.no_sync():
            # Gradients only accumulate
            outputs = ddp_model(inputs)
            loss = loss_func(outputs)
            accelerator.backward(loss)
    else:
        # Gradients finally sync
        outputs = ddp_model(inputs)
        loss = loss_func(outputs)
        accelerator.backward(loss)
        optimizer.step()
```

`ddp_model.no_sync`를 [no_sync()](/docs/accelerate/v1.16.0/ko/package_reference/accelerator#accelerate.Accelerator.no_sync)로 대체하여, 어떤 학습 장치를 사용하든 호출할 수 있는 API로 만들었습니다(분산 시스템이 아닌 경우 아무 동작도 하지 않을 수 있습니다!). 동작 방식은 동일합니다:

```diff
  ddp_model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)

  for index, batch in enumerate(dataloader):
      inputs, targets = batch
      # Trigger gradient synchronization on the last batch
      if index != (len(dataloader)-1):
-         with ddp_model.no_sync():
+         with accelerator.no_sync(model):
              # Gradients only accumulate
              outputs = ddp_model(inputs)
              loss = loss_func(outputs, targets)
              accelerator.backward(loss)
      else:
          # Gradients finally sync
          outputs = ddp_model(inputs)
          loss = loss_func(outputs)
          accelerator.backward(loss)
          optimizer.step()
          optimizer.zero_grad()
```

예상하시듯, [accumulate()](/docs/accelerate/v1.16.0/ko/package_reference/accelerator#accelerate.Accelerator.accumulate) 함수는 현재 배치 번호를 추적하여 이 조건부 검사를 감싸며, 최종적인 그라디언트 축적 API를 제공합니다:

```python
ddp_model, dataloader, optimizer = accelerator.prepare(model, dataloader, optimizer)

for batch in dataloader:
    with accelerator.accumulate(model):
        optimizer.zero_grad()
        inputs, targets = batch
        outputs = model(inputs)
        loss = loss_function(outputs, targets)
        accelerator.backward(loss)
        optimizer.step()
        optimizer.zero_grad()
```

따라서 API 선택 시 *`accelerator.accumulate` 또는 `accelerator.no_sync`*를 사용해야 합니다.

## 정확히 얼마나 지연이 발생하며, 쉽게 범할 수 있는 실수

현실적인 예시를 설정하기 위해 다음 구성을 고려해 보겠습니다.

* 싱글 GPU T4 노드 2개와 2개의 GPU를 가진 노드 1개
* 각 GPU는 T4이며 GCP에 호스팅됩니다
* 사용된 스크립트는 [NLP Example](https://github.com/muellerzr/timing_experiments/blob/main/baseline.py) 스크립트의 수정 버전입니다
* GPU당 배치 크기는 16이며, 4단계마다 그래디언트가 누적됩니다

모든 스크립트는 [이 저장소](https://github.com/muellerzr/timing_experiments)에서 사용할 수 있습니다.

그라디언트 동기화와 GPU 통신에 주의하지 않으면, 불필요한 시기에 GPU 간 통신이 발생하여 *많은* 시간이 낭비될 수 있습니다.

얼마나?

참고:
- Baseline: 여기에서 논의된 동기화 기법을 사용하지 않습니다
- `no_sync`을 잘못 사용하는 경우: `no_sync`를 `backward` 호출 주위에만 사용하고 `forward`에는 사용하지 않는 경우
- `no_sync`: `no_sync` 패턴을 올바르게 사용하는 방법
- `accumulate`: [accumulate()](/docs/accelerate/v1.16.0/ko/package_reference/accelerator#accelerate.Accelerator.accumulate)를 올바르게 사용하는 방법

은 단일 노드와 듀얼 노드 설정에서 각각 29개의 배치 데이터를 반복할 때 설정별 평균 배치당 초를 나타냅니다:

|             | 베이스라인  | `no_sync`을(를) 부적절하게 | `no_sync` | `accumulate`| 
| :---------: | :-------: | :------------------: | :-------: | :---------: |
| 멀티 노드  | 2±0.01s    | 2.13±0.08s | **0.91±0.11s** | **0.91±0.11s** |
| 단일 노드 | 0.50±0.01s | 0.50±0.01s | **0.41±0.015s** | **0.41±0.015s** |

알 수 있듯이, 그라디언트 동기화를 설정하는 방법에 대해 주의하지 않으면 학습 중에 2배 이상의 성능 저하가 발생할 수 있습니다!

모든 작업이 올바르게 수행되는지 걱정된다면, [accumulate()](/docs/accelerate/v1.16.0/ko/package_reference/accelerator#accelerate.Accelerator.accumulate) 함수를 사용하고 `gradient_accumulation_steps` 또는 `gradient_accumulation_plugin`를 [Accelerator](/docs/accelerate/v1.16.0/ko/package_reference/accelerator#accelerate.Accelerator) 객체에 전달하여 Accelerate가 이 작업을 처리하도록 하는 것을 강력히 권장합니다.

### `no_sync`는 FSDP를 사용할 때 추가 GPU 메모리가 필요합니다

FSDP 학습을 수행하는 동안 그라디언트를 동기화하지 않으면 부정적인 영향을 미칠 수 있음을 유의하세요. `torch`에서 경고한 바와 같이, FSDP용 [`no_sync` 컨텍스트 매니저](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.FullyShardedDataParallel.no_sync)는 추가 메모리가 필요합니다.

따라서 FSDP를 사용하는 동안 메모리 집약적인 상황에서는 [GradientAccumulationPlugin](/docs/accelerate/v1.16.0/ko/package_reference/utilities#accelerate.utils.GradientAccumulationPlugin)에서 `sync_each_batch`를 `True`로 설정하여 `no_sync`를 비활성화하는 것을 권장합니다.

아래 예시에서는 8개의 A100-80GB GPU에서 Mixtral(47B 파라미터)을 fine-tune하는 과정을 보여줍니다. `gradient_accumulation_steps=2`와 같이 modest한 값에서도 `no_sync`가 활성화되어 있으면 빠르게 out-of-memory(OOM)가 발생합니다. 이는 다시 한번 FSDP의 `no_sync`로 인한 추가적인 메모리 오버헤드 때문입니다. 그러나 `sync_each_batch=True`를 통해 `no_sync`를 비활성화하면, `gradient_accumulation_steps=16`의 메모리 사용량은 `gradient_accumulation_steps=1`의 수준으로 돌아갑니다.

| 모델           | `no_sync` (accum=1) | `no_sync` (accum=2) | `no_sync` 비활성화 (accum=16) | :-------------: | :-----------------: | :-----------------: | :-----------------: mixtral 8x7B      | 69G                 | OOM                 | 69G

> [!WARNING] 
> `no_sync`를 비활성화하면 이 가이드의 이전 섹션에서 설명한 대로 추가 데이터 동기화로 인해 _속도가 느려집니다_.

