Accelerate documentation

DDP İletişim Kancaları

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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ı

PyTorch
Accelerate
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()

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.

PyTorch
Accelerate
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()

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.

PyTorch
Accelerate
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()

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.

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.

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 başvurun.

Update on GitHub