Çoklu GPU iş yükü

Önemli

Bu özellik Beta sürümündedir. Çalışma alanı yöneticileri Bu özelliğe erişimi Önizlemeler sayfasından denetleyebilir. Bkz. Azure Databricks önizlemelerini yönetme.

Sunucusuz GPU Python API'sini kullanarak tek bir düğümde birden çok GPU'da dağıtılmış iş yüklerini başlatabilirsiniz. API, GPU sağlama, ortam kurulumu ve iş yükü dağıtımı ayrıntılarını soyutlayan basit, birleşik bir arabirim sağlar. En az kod değişikliğiyle tek GPU eğitiminden aynı not defterinden çok GPUlu dağıtılmış yürütmeye sorunsuz bir şekilde geçiş yapabilirsiniz.

Desteklenen çerçeveler

API, @distributed önemli dağıtılmış eğitim kitaplıklarıyla entegre olur.

PyTorch Dağıtılmış Veri Paralel (DDP) — Standart çok GPU'lu veri paralelliği.
Tam Parçalı Veri Paralel (FSDP) — Büyük modeller için bellek açısından verimli eğitim.
DeepSpeed — Microsoft'un büyük model eğitimi için iyileştirme kitaplığı.

serverless_gpu API ile TorchDistributor karşılaştırması

Aşağıdaki tablo API'yi serverless_gpu@distributedTorchDistributor ile karşılaştırır:

Özellik	`serverless_gpu` `@distributed` API	TorchDistributor
Altyapı	Tamamen sunucusuz, küme yönetimi yok	GPU çalışanlarıyla spark kümesi gerektirir
Kurulum	Tek dekoratör, minimum yapılandırma	Spark kümesi ve TorchDistributor kurulumu gerektirir
Çerçeve desteği	PyTorch DDP, FSDP, DeepSpeed	Öncelikli olarak PyTorch DDP
Veri yükleme	İç mekan dekoratörü, Unity Katalog Hacimlerini kullanır	Spark veya dosya sistemi aracılığıyla

serverless_gpu API, Databricks'te yeni derin öğrenme iş yükleri için önerilen yaklaşımdır. TorchDistributor, Spark kümeleri ile sıkı bir şekilde birbirine bağlı iş yükleri için kullanılabilir durumda kalır.

Hızlı başlangıç

Dağıtılmış eğitim için sunucusuz GPU API'si, Databricks not defterleri ve işleri içindeki sunucusuz bir GPU'ya bağlandığınızda önceden yüklenir. GPU ortamı 4 ve üzerini öneririz. Dağıtılmış eğitimde kullanmak için, eğitim işlevinizi dağıtmak üzere distributed dekoratörünü içe aktarın ve kullanın.

Model eğitim kodunu bir fonksiyon içerisine alın ve bu fonksiyona @distributed dekoratörü ekleyin. Düzenlenmiş işlev, dağıtılmış yürütme için giriş noktası haline gelir; tüm eğitim mantığı, veri yükleme ve model başlatma bu işlevin içinde tanımlanmalıdır.

Uyarı

gpu_type içindeki @distributed parametresi, not defterinizin bağlı olduğu hızlandırıcı türüyle eşleşmelidir. Örneğin, @distributed(gpus=8, gpu_type='H100') not defterinizin bir H100 hızlandırıcısına bağlı olmasını gerektirir. Eşleşmeyen hızlandırıcı türü kullanmak (H100 belirtirken A10'a bağlanmak gibi) iş yükünün başarısız olmasına neden olur.

Aşağıdaki kod parçacığı temel kullanımını @distributedgösterir:

# Import the distributed decorator
from serverless_gpu import distributed

# Decorate your training function with @distributed and specify the number of GPUs and GPU type
@distributed(gpus=8, gpu_type='H100')
def run_train():
    ...

Aşağıda, bir notebook üzerinde 8 H100 GPU kullanarak çok katmanlı algılayıcı (MLP) modelini eğiten tam bir örnek verilmiştir:

Modelinizi ayarlayın ve yardımcı program işlevlerini tanımlayın.


# Define the model
import os
import torch
import torch.distributed as dist
import torch.nn as nn

def setup():
    dist.init_process_group("nccl")
    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))

def cleanup():
    dist.destroy_process_group()

class SimpleMLP(nn.Module):
    def __init__(self, input_dim=10, hidden_dim=64, output_dim=1):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(hidden_dim, output_dim)
        )

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

serverless_gpu kitaplığını ve dağıtılmış modülü içeri aktarın.
```
import serverless_gpu
from serverless_gpu import distributed
```

Model eğitim kodunu bir fonksiyon içerisine alın ve bu fonksiyona @distributed dekoratörü ekleyin.

@distributed(gpus=8, gpu_type='H100')
def run_train(num_epochs: int, batch_size: int) -> None:
    import mlflow
    import torch.optim as optim
    from torch.nn.parallel import DistributedDataParallel as DDP
    from torch.utils.data import DataLoader, DistributedSampler, TensorDataset

    # 1. Set up multi-GPU environment
    setup()
    device = torch.device(f"cuda:{int(os.environ['LOCAL_RANK'])}")

    # 2. Apply the Torch distributed data parallel (DDP) library for data-parellel training.
    model = SimpleMLP().to(device)
    model = DDP(model, device_ids=[device])

    # 3. Create and load dataset.
    x = torch.randn(5000, 10)
    y = torch.randn(5000, 1)

    dataset = TensorDataset(x, y)
    sampler = DistributedSampler(dataset)
    dataloader = DataLoader(dataset, sampler=sampler, batch_size=batch_size)

    # 4. Define the training loop.
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    loss_fn = nn.MSELoss()

    for epoch in range(num_epochs):
        sampler.set_epoch(epoch)
        model.train()
        total_loss = 0.0
        for step, (xb, yb) in enumerate(dataloader):
            xb, yb = xb.to(device), yb.to(device)
            optimizer.zero_grad()
            loss = loss_fn(model(xb), yb)
            # Log loss to MLflow metric
            mlflow.log_metric("loss", loss.item(), step=step)

            loss.backward()
            optimizer.step()
            total_loss += loss.item() * xb.size(0)

        mlflow.log_metric("total_loss", total_loss)
        print(f"Total loss for epoch {epoch}: {total_loss}")

    cleanup()

Kullanıcı tanımlı bağımsız değişkenlerle dağıtılmış işlevi çağırarak dağıtılmış eğitimi gerçekleştirin.
```
run_train.distributed(num_epochs=3, batch_size=1)
```
Çalıştırıldığında, not defteri hücresinin çıktısında bir MLflow çalıştırma bağlantısı oluşturulur. Çalıştırma sonuçlarını görmek için MLflow çalıştırma bağlantısına tıklayın veya Deneme panelinde bulun.

Dağıtılmış yürütme ayrıntıları

Sunucusuz GPU API'si birkaç temel bileşenden oluşur:

İşlem yöneticisi: Kaynak ayırma ve yönetimi işler
Çalışma zamanı ortamı: Python ortamlarını ve bağımlılıklarını yönetir
Başlatıcı: İş yürütme ve izlemeyi düzenler

Dağıtılmış modda çalışırken:

İşlev serileştirilir ve belirtilen sayıda GPU'ya dağıtılır
Her GPU işlevin bir kopyasını aynı parametrelerle çalıştırır
Ortam, tüm GPU'lar arasında senkronize edilir.
Sonuçlar tüm GPU'lardan toplanır ve döndürülür

API, Dağıtılmış Veri Paralel (DDP), Tam Parçalı Veri Paralel (FSDP), DeepSpeed gibi popüler paralel eğitim kitaplıklarını destekler.

Not defteri örneklerindeki çeşitli kitaplıkları kullanarak daha gerçek dağıtılmış eğitim senaryoları bulabilirsiniz.

FAQs

Veri yükleme kodu nereye yerleştirilmelidir?

Dağıtılmış eğitim için Sunucusuz GPU API'sini kullanırken veri yükleme kodunu @distributed dekoratörün içine taşıyın. Veri kümesi boyutu, turşunun izin verdiği boyut üst sınırını aşabilir, bu nedenle aşağıda gösterildiği gibi veri kümesinin dekoratör içinde oluşturulması önerilir:

from serverless_gpu import distributed

# this may cause pickle error
dataset = get_dataset(file_path)
@distributed(gpus=8, gpu_type='H100')
def run_train():
  # good practice
  dataset = get_dataset(file_path)
  ....

Daha fazla bilgi edinin

API başvurusu için Sunucusuz GPU Python API belgelerine bakın.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-03-21