# DDP İletişim Kancaları

Distributed Data Parallel (DDP) iletişim kancaları, `DistributedDataParallel` içindeki standart allreduce işlemini devre dışı bırakarak gradyanların işçiler arasında nasıl iletileceğini kontrol etmek için genel bir arayüz sağlar. Birkaç yerleşik iletişim kancası sunulmakta olup kullanıcılar, iletişimi optimize etmek için bu kancalardan herhangi birini kolayca uygulayabilir.

- **FP16 Sıkıştırma Kancası**: Gradyanları yarı hassasiyetli kayan nokta biçimine (`torch.float16`) dönüştürerek sıkıştırır ve iletişim yükünü azaltır.
- **BF16 Sıkıştırma Kancası**: FP16'ye benzer, ancak belirli donanımlarda daha verimli olabilecek Beyin Yüzen Nokta biçimini (`torch.bfloat16`) kullanır.
- **PowerSGD Hook**: Yüksek sıkıştırma oranları sağlayarak bant genişliği kısıtlı dağıtık eğitimi hızlandırabilen gelişmiş bir gradyan sıkıştırma algoritması.

Bu eğitimde, Accelerate tarafından sağlanan yardımcılarla DDP iletişim kancalarını (communication hooks) nasıl hızlıca kurabileceğinizi ve eğitim yapabileceğinizi göreceksiniz; bu işlem, yalnızca bir satır yeni kod eklemek kadar basit olabilir! Bu, Accelerate kütüphanesiyle dağıtık eğitimde gradyan iletişimini optimize etmek için DDP iletişim kancalarının nasıl kullanılacağını göstermektedir.

## FP16 Sıkıştırma Kancası

```python
import torch
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.distributed.algorithms.ddp_comm_hooks import default_hooks
from accelerate.test_utils.testing import get_backend

device_type, _, _ = get_backend()
device_id = getattr(torch, device_type, torch.cuda).current_device()

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

model = MyModel()
model = DDP(model, device_ids=[device_id])
model.register_comm_hook(state=None, hook=default_hooks.fp16_compress_hook)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()
```

```python
from accelerate import Accelerator, DDPCommunicationHookType, DistributedDataParallelKwargs
import torch

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

# DDP Communication Hook setup
ddp_kwargs = DistributedDataParallelKwargs(comm_hook=DDPCommunicationHookType.FP16)
accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])

model = MyModel()
optimizer = torch.optim.Adam(model.parameters())
data_loader = DataLoader(dataset, batch_size=16)

model, optimizer, data_loader = accelerator.prepare(model, optimizer, data_loader)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    accelerator.backward(loss)
    optimizer.step()
    optimizer.zero_grad()
```

### BF16 Sıkıştırma Kancası

BF16 Sıkıştırma Kancası API'si deneyseldir ve 2.9.6'dan sonraki bir NCCL sürümü gerektirir.

```python
import torch
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.distributed.algorithms.ddp_comm_hooks import default_hooks
from accelerate.test_utils.testing import get_backend

device_type, _, _ = get_backend()
device_id = getattr(torch, device_type, torch.cuda).current_device()

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

model = MyModel()
model = DDP(model, device_ids=[device_id])
model.register_comm_hook(state=None, hook=default_hooks.bf16_compress_hook)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()
```

```python
from accelerate import Accelerator, DDPCommunicationHookType, DistributedDataParallelKwargs
import torch

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

# DDP Communication Hook setup
ddp_kwargs = DistributedDataParallelKwargs(comm_hook=DDPCommunicationHookType.BF16)
accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])

model = MyModel()
optimizer = torch.optim.Adam(model.parameters())
data_loader = DataLoader(dataset, batch_size=16)

model, optimizer, data_loader = accelerator.prepare(model, optimizer, data_loader)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    accelerator.backward(loss)
    optimizer.step()
    optimizer.zero_grad()
```

### PowerSGD Kancası

PowerSGD, önyargılı sıkıştırılmış iletişimi telafi edebilmek ve doğruluğu iyileştirmek için hata geri bildirimi etkinleştirmek amacıyla, modelin gradyanlarıyla aynı boyutta ek bellek gerektirir.

```python
import torch
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.distributed.algorithms.ddp_comm_hooks import powerSGD_hook
from accelerate.test_utils.testing import get_backend

device_type, _, _ = get_backend()
device_id = getattr(torch, device_type, torch.cuda).current_device()

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

model = MyModel()
model = DDP(model, device_ids=[device_id])
state = powerSGD_hook.PowerSGDState(process_group=None)
model.register_comm_hook(state=state, hook=powerSGD_hook.powerSGD_hook)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()
```

```python
from accelerate import Accelerator, DDPCommunicationHookType, DistributedDataParallelKwargs
import torch

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

# DDP Communication Hook setup
ddp_kwargs = DistributedDataParallelKwargs(comm_hook=DDPCommunicationHookType.POWER_SGD)
accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])

model = MyModel()
optimizer = torch.optim.Adam(model.parameters())
data_loader = DataLoader(dataset, batch_size=16)

model, optimizer, data_loader = accelerator.prepare(model, optimizer, data_loader)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    accelerator.backward(loss)
    optimizer.step()
    optimizer.zero_grad()
```

## DDP İletişim Kancaları yardımcıları

İletişim kancalarıyla isteğe bağlı işlevselliği desteklemek için iki ek yardımcı araç bulunmaktadır.

### comm_wrapper

`comm_wrapper`, bir iletişim kancasını ek işlevselliklerle sarmak için bir seçenektir. Örneğin, FP16 sıkıştırmasını diğer iletişim stratejileriyle birleştirmek için kullanılabilir. Şu anda desteklenen sarmalayıcılar `no`, `fp16` ve `bf16`'dır.

```python
from accelerate import Accelerator, DDPCommunicationHookType, DistributedDataParallelKwargs
import torch

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

# DDP Communication Hook setup
ddp_kwargs = DistributedDataParallelKwargs(
    comm_hook=DDPCommunicationHookType.POWER_SGD,
    comm_wrapper=DDPCommunicationHookType.FP16
)
accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])

model = MyModel()
optimizer = torch.optim.Adam(model.parameters())
data_loader = DataLoader(dataset, batch_size=16)

model, optimizer, data_loader = accelerator.prepare(model, optimizer, data_loader)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    accelerator.backward(loss)
    optimizer.step()
    optimizer.zero_grad()
```

### comm_state_option

`comm_state_option`, belirli iletişim kancalarının gerektirdiği ek durum bilgilerini iletmenizi sağlar. Bu, eğitim adımları arasında hiperparametreleri ve iç durumları korumayı gerektiren `PowerSGD` gibi durumlu kancalar için özellikle faydalıdır. Aşağıda, `PowerSGD` kancasıyla `comm_state_option` kullanımını gösteren bir örnek bulunmaktadır.

```python
from accelerate import Accelerator, DDPCommunicationHookType, DistributedDataParallelKwargs
import torch

class MyModel(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.layer = torch.nn.Linear(10, 10)

    def forward(self, x):
        return self.layer(x)

# DDP Communication Hook setup
ddp_kwargs = DistributedDataParallelKwargs(
    comm_hook=DDPCommunicationHookType.POWER_SGD,
    comm_state_option={"matrix_approximation_rank": 2}
)
accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])

model = MyModel()
optimizer = torch.optim.Adam(model.parameters())
data_loader = DataLoader(dataset, batch_size=16)

model, optimizer, data_loader = accelerator.prepare(model, optimizer, data_loader)

# Training loop
for data, targets in data_loader:
    outputs = model(data)
    loss = criterion(outputs, targets)
    accelerator.backward(loss)
    optimizer.step()
    optimizer.zero_grad()
```

Daha gelişmiş kullanım ve ek kanca (hook)lar için [PyTorch DDP İletişim Kanca (Hook)ları belgelerine](https://pytorch.org/docs/stable/ddp_comm_hooks.html) başvurun.

