Not defterlerinde dağıtılmış eğitim

Ö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.

@distributed Sunucusuz GPU Python API'sinden dekoratör, bir Databricks dizüstü bilgisayarından dağıtık eğitim çalıştırmanın en pratik yoludur. Eğitim fonksiyonunuzu bir dekoratörle işaretleyin, çağırın; AI Runtime da bunu notebook’unuzun bağlı olduğu düğüm üzerindeki tüm GPU’larda çalıştırır. Aynı kod, tek GPU'dan çoklu GPU'ya, kurulacak bir küme ve yapılandırılacak bir dağıtık başlatıcı gerektirmeden ölçeklenebilir.

Tip

• @distributed dekoratörü, bir not defterinden düğümünüzdeki her GPU'da bir eğitim işlevi çalıştırır.
• PyTorch DDP, FSDP ve DeepSpeed'i destekliyor ve tek GPU kodunu çok az değişiklikle çoklu GPU'ya taşıyor.
• Notebookunuzu 8xH100 hızlandırıcıya bağlayın ve tam çoklu GPU eğitimi için ayarlayın gpus=8 .

Quickstart

Paket, serverless_gpu dizüstü bilgisayarınız sunucusuz bir GPU'ya bağlıyken önceden kuruludur. Eğitim fonksiyonunuzu @distributed ile işaretleyin, ardından .distributed() ile çağırın:

from serverless_gpu import distributed

# gpus is the number of GPUs on the node. gpu_type is optional and
# auto-detected from the accelerator your notebook is connected to.
@distributed(gpus=8, gpu_type="H100")
def train():
    import os
    import torch
    import torch.distributed as dist

    # Bind this process to its own GPU before training.
    local_rank = int(os.environ["LOCAL_RANK"])
    torch.cuda.set_device(local_rank)
    device = torch.device(f"cuda:{local_rank}")
    dist.init_process_group("nccl")
    # ... build the model and data on `device`, then run your training loop ...
    dist.destroy_process_group()

train.distributed()

Her .distributed() çağrıda bir MLflow çalıştırması oluşturulur (veya zaten etkin bir çalıştırma varsa iç içe bir alt çalıştırma oluşturulur) ve hücre çıktısında bir çalıştırma bağlantısı görüntülenir. Tam ve çalıştırılabilir bir adım adım kılavuz için Tam örnek bölümüne bakın.

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.
• Tamamen Parçalanmış Veri Paralelliği (FSDP): Büyük modellerin eğitimi için bellek açısından verimli.
• DeepSpeed: büyük model eğitimi için Microsoft iyileştirme kitaplığı.

Her kütüphaneyi kullanan gerçek eğitim senaryoları için defter örneklerine bakınız.

Dekoratör @distributed nasıl çalışır

Dekoratör uygulanmış bir fonksiyonu .distributed() ile çağırdığınızda AI Runtime, normalde dağıtık bir başlatıcıyla elle yapılandıracağınız altyapı ayrıntılarını sizin yerinize üstlenir:

• Serileştirme ve yayma: Fonksiyon, istediğiniz her gpus bir durumda serileştirilir ve başlatılır. Her GPU, aynı argümanlarla fonksiyonun bir kopyasını çalıştırır.
• Ortam senkronizasyonu: Python ortamı ve bağımlılıkları tüm rütbelerde çoğaltılır, böylece her süreç aynı kodu çalıştırır.
• Sıralama ortam değişkenleri: LOCAL_RANK gibi standart değişkenler her işlem için doldurulur. Modeli ve verileri doğru cihaza yerleştirmek için bunları fonksiyonunuz içinde okuyun.
• Sonuç toplama: Tüm rütbelerden iade değerleri toplanır ve çağırana geri verilir.
• MLflow takibi: Her .distributed() çağrı bir MLflow çalıştırışı veya zaten aktifse iç içe bir çocuk çalıştırma oluşturur, böylece fonksiyonunuzdan kaydedilen metrikler aynı çalıştırmaya düşer.
• Yaşam döngüsü ve zaman aşımı: Dağıtık yürütme, notebookun yaşam döngüsü içinde çalışır. Defteri sonlandırınca çalışma sona erer. Decorator'ün varsayılan zaman aşımı süresi 3 saattir. Değiştirmek için saniye cinsinden timeout girin veya devre dışı bırakmak için timeout=None girin. Özel zaman aşımları için GPU ortamı v5 ve üzeri gerekir.

API, standart PyTorch kütüphaneleri üzerine inşa edilmiştir: Dağıtılmış Veri Paralel (DDP), Tam Parçalanmış Veri Paralel (FSDP) ve DeepSpeed.

TorchDistributor'dan geliyor

Bugün Spark üzerinde TorchDistributor ile dağıtılmış PyTorch çalıştırıyorsanız ve iş yükünüz tek bir düğüme sığıyorsa, serverless_gpu@distributed API’si yeni derin öğrenme iş yükleri için önerilen alternatiftir. Spark kümesini kaldırıyor ve tek GPU'dan çoklu GPU'ya aynı kod yolunu sunuyor.

Ö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	Dekoratör içinde, dosya verilerinin akışı için Unity Catalog birimleri (UCVolumeDataset) kullanılır.	Spark veya dosya sistemi aracılığıyla

Tek düğümlü iş yükünü taşımak için:

• train_fn üzerinde TorchDistributor(...).run(train_fn, ...) çağrısını @distributed dekoratörüyle değiştirin, ardından train_fn.distributed(...) ile başlatın.
• Spark kümesini ve GPU çalışanı yapılandırmasını kaldırın. Notebook'unuzu 8xH100 hızlandırıcısına bağlayın ve bunun yerine gpus=8 olarak ayarlayın.
• Veri yüklemesini süslü fonksiyonun içine taşıyın. Veri yükleme bölümünü inceleyin.
• Mevcut DDP, FSDP veya DeepSpeed model kodunuzu koruyun. Dekoratör üçünü de destekler.

@distributed tek bir düğümde çalışır ( bkz. Sınırlamalar), bu yüzden her TorchDistributor iş yükünü değiştirmez. Spark entegrasyonuna bağlı iş yüklerini TorchDistributor'da tutun. Yerel makinenizden veya birden fazla düğüm arasında dağıtık eğitim çalıştırmak için, bunun yerine Public Preview içindeki AI Runtime CLI'yı kullanın. Bkz. AI Runtime CLI.

Tam örnek

Aşağıdaki örnek, bir dizüstü bilgisayardan 8 H100 GPU üzerinde çok katmanlı bir perceptron (MLP) modelini eğitmektedir.

1. 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():
       torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
       dist.init_process_group("nccl")
   
   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)
   

2. serverless_gpu kitaplığını ve distributed modülünü içeri aktarın.

   import serverless_gpu
   from serverless_gpu import distributed
   

3. Model eğitim kodunu bir fonksiyon içerisine alın ve bu fonksiyona @distributed dekoratörü ekleyin. Süslenmiş fonksiyon, dağıtık yürütme için giriş noktasıdır, bu nedenle tüm eğitim mantığı, veri yükleme ve model başlatma sürecini içinde tanımlayın.

   @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()
   

4. Dağıtık eğitimi, kullanıcı tanımlı argümanlarla dağıtılmış fonksiyonu çağırarak çalıştırın.

   run_train.distributed(num_epochs=3, batch_size=1)
   

5. Çalıştırıldığında, notebook hücresinin çıktısında bir MLflow çalışma 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. Deneme adlarını özelleştirme, ölçümleri izleme ve çalıştırmaları sürdürme hakkında ayrıntılar için bkz: Deneme izleme ve gözlemlenebilirlik.

Veri yükleme

Fonksiyonun @distributed içine veri yükleme kodunu yerleştirin. Bir veri seti, izin verilen picklemaksimum boyutu aşabilir, bu nedenle onu dekoratör içinde oluşturmak veya yüklemek, serileştirme hatalarını önler:

from serverless_gpu import distributed

# This may cause a pickle error because the dataset is captured by the function.
dataset = get_dataset(file_path)

@distributed(gpus=8, gpu_type='H100')
def run_train():
    # Load the dataset inside the decorated function instead.
    dataset = get_dataset(file_path)
    ...

Unity Catalog birimlerinde depolanan dosya tabanlı veriler için, dosyaları yerel önbellekleme ile akış halinde okuyan ve bunları rank'ler ile çalışanlar arasında otomatik olarak bölümleyen UCVolumeDataset öğesini serverless_gpu.data içinden kullanın. Dağıtılmış eğitimin denetim noktalarını bir depolama birimine kaydetmek için UCVolumeWriter ve UCVolumeReader kullanın. Bkz. AI Runtime'a veri yükleme ve Model denetim noktalarının kaydedilmesi.

Limitations

• Dağıtık eğitim, dizüstü bilgisayarınızın bağlı olduğu tek düğümdeki GPU'lar arasında çalışır. Tam çoklu GPU eğitimi için, 8 GPU’lu tek bir düğüm sağlayan 8xH100 hızlandırıcısına bağlanın ve gpus=8 ayarlayın.
• Hızlandırıcı türü aynı olmalıdır. @distributed içinde gpu_type ayarlarsanız, notebook'unuzun bağlı olduğu hızlandırıcıyla ("H100" veya "A10") aynı olmalıdır. Bir uyumsuzluk iş yükünün başarısız olmasına neden olur. Parametre isteğe bağlıdır ve çıkarıldığında otomatik olarak algılanır.
• AI Runtime, GPU ortamı v4 ve üzerini öneriyor. Özel zaman aşımları ( timeout parametre) için GPU ortamı v5 ve üzeri gerekiyor.
• Dekoratör varsayılan olarak 3 saat sonra zaman aşımına uğrar. Değiştirmek için saniye cinsinden timeout girin veya devre dışı bırakmak için timeout=None girin.
• Yürütme işlemi, notebook'un yaşam döngüsü içinde gerçekleşir. Defteri sonlandırınca çalışma sona erer.

Daha fazla bilgi edinin

• Dekoratör GPUTypeve Ray API'leri için @distributedSunucusuz GPU Python API referans dokümantasyonuna bakınız.
• Eğitim hattınızı daha verimli ve dayanıklı hale getiren kalıplar için performans ve dayanıklılık rehberine bakınız.
• Uçtan uca eğitim senaryoları için defter örneklerine bakınız.