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.

Uyarı

Bu sayfa, sunucusuz GPU Python API'sine sahip Databricks not defterlerinden dağıtılmış eğitimi kapsar. Dağıtılmış eğitim iş yüklerini yerel makinenizden göndermek için Genel Önizleme'deki AI Runtime CLI'sini kullanın. Bkz. AI Runtime CLI.

Sunucusuz GPU Python API 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.

Uyarı

Dağıtılmış eğitim, 8 GPU ile tek bir düğüm sağlayan 8xH100 hızlandırıcısı gerektirir. @distributed dekoratörünü kullanırken gpus=8 ayarlayın. gpu_type parametresi isteğe bağlıdır ve not defterinizin bağlı olduğu hızlandırıcıdan otomatik olarak algılanır.

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ığı.

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	İç dekoratörde Unity Katalog Birimleri (UCVolumeDataset akış dosyası verileri için) kullanılı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, bu nedenle tüm eğitim mantığı, veri yükleme ve model başlatma bu işlevin içinde tanımlanmalıdır.

Dağıtılmış yürütmeyi başlatmak için, dekore edilmiş işlevinizi train_function.distributed() kullanarak çağırın. Her çağrı, otomatik olarak bir MLflow deneme çalışması veya zaten etkin bir çalışma varsa iç içe bir alt çalışma oluşturur.

Uyarı

gpu_type içinde @distributed ayarlanıyorsa, bunun not defterinizin bağlı olduğu hızlandırıcı türüyle ("H100" veya "A10") eşleştiğinden emin olun. Yanlış hızlandırıcı türü belirtilmesi 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:

from serverless_gpu import distributed

# Decorate your training function with @distributed and specify the number of GPUs.
# gpu_type='H100' is optional and will be auto-detected if not set.
@distributed(gpus=8, gpu_type='H100')
def run_train():
    ...

run_train.distributed()

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

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.

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

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.

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
• Yaşam döngüsü yönetimi: Dağıtılmış yürütme, not defterinin yaşam döngüsü içinde çalışır. Notebook sonlandığında, yürütme de sonlanır. @distributed dekoratörünün varsayılan zaman aşımı süresi 3 saattir. Özel bir zaman aşımı ayarlamak için, saniye cinsinden timeout değerini girin veya bunu devre dışı bırakmak için timeout=None değerini kullanın. Zaman aşımını ayarlamak, GPU ortamı v5 ve üzerinde kullanılabilir.

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.

Eğitim hattınızı daha verimli ve dayanıklı hale getirecek tavsiyeler ve kalıplar için performans ve dayanıklılık rehberine bakabilirsiniz.

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

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.

Daha fazla bilgi edinin

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