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

Important

Bu özellik Beta sürümündedir.

@distributed Databricks AI Runtime SDK'sındaki dekoratörü (databricks-sdk-air), bir Databricks notebook'tan dağıtık eğitimi ç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.

Bu sayfadaki önemli noktalar:

• @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.
• Tam çoklu GPU eğitimi için dizüstü bilgisayarınızı 8xH100 hızlandırıcıya bağlayın. Varsayılan olarak, @distributed düğümdeki tüm GPU'ları kullanır.

Note

Bu sayfa, Databricks AI Runtime SDK ile Databricks defterlerinden dağıtık eğitimi kapsar. Yerel makinenizden dağıtık eğitim iş yükü göndermek için AI Runtime için Databricks CLI komutlarını kullanın. Bkz. Databricks CLI'yı AI Çalışma Zamanı ile Kullanın.

Quickstart

Bu sayfadaki örnekler, GPU ortamı sürüm 6 ve üzerinde, önceden yüklenmiş olan Databricks AI Runtime SDK'yı kullanır. 5 ve altındaki sürümlerde bunun yerine serverless_gpu paketini kullanın. Bkz. serverless_gpu öğesinden geçiş. Bir dizüstü bilgisayarı hızlandırıcıya bağlamak için Adım 1: Bir notebook'u GPU'ya bağlayın.

Eğitim fonksiyonunuzu @distributed ile işaretleyin, ardından .distributed() ile çağırın:

from databricks.air import distributed

# By default, @distributed uses every GPU on the node your notebook is connected
# to. To use fewer, pass num_accelerators (for example, num_accelerators=2).
@distributed()
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()

Dağıtılmış eğitim, 8 GPU ile tek bir düğüm sağlayan 8xH100 hızlandırıcısı gerektirir. Varsayılan olarak, @distributed sekiz GPU'nun tamamını kullanır. num_accelerators daha az kullanacak şekilde ayarlayın. Bu accelerator_type parametre de isteğe bağlıdır ve not defterinizin bağlı olduğu hızlandırıcıdan otomatik olarak algılanır.

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 altyapılar

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 bir kitaplığı kullanan gerçek eğitim senaryoları için dağıtık eğitim ö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 fan-out: Fonksiyon serileştirilir ve seçilen her GPU'da 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.

şundan geçiş yap serverless_gpu

serverless_gpu paketi artık kullanımdan çıkmış ve yeni özellikler eklenmiyor. GPU ortamı 6. sürümden itibaren, Databricks AI Runtime SDK (databricks-sdk-air) onun yerini alır ve yeniden adlandırılmış argümanlarla, databricks.air ad alanı altında eşdeğer API'ler sağlar. Kullandığınız paket, GPU ortam sürümüne bağlıdır:

• Sürüm 5 ve alt: Sadece serverless_gpu. Bu versiyonlarda serverless_gpu kullanmaya devam edin.
• Sürüm 6: Her iki paketi de içerir, ancak yalnızca AI Çalışma Zamanı SDK'sı güncellemeler alır. Sürüm 6, serverless_gpu içeren son GPU ortamı sürümüdür.

AI Çalışma Zamanı SDK, Python için Databricks SDK'sından ayrı bir pakettir (databricks-sdk).

	serverless_gpu (kullanım dışı)	AI Çalışma Zamanı SDK'sı (databricks.air)
GPU ortamı sürümleri	6 ve altı	6 ve üzeri
Import	from serverless_gpu import distributed, ray_init	from databricks.air import distributed, ray_init
GPU sayısı parametresi	gpus	num_accelerators
GPU türü bağımsız değişkeni	gpu_type (GPUType)	accelerator_type (AcceleratorType)
GPU tipi değerleri	"A10", "H100", "B300"	"GPU_1xA10", "GPU_1xH100", "GPU_8xH100", "GPU_8xB300"
Veri yükleme ve kontrol noktası modülü	serverless_gpu.data	databricks.air.data. Bkz . Yapay zeka çalışma zamanına veri yükleme.

Bir not defterini taşımak için:

1. Notebook'u, AI Runtime SDK'yı içeren GPU ortamı sürüm 6 veya üzerine bağlayın.
2. İçe aktarmaları serverless_gpu'den databricks.air'e değiştirin.
3. num_accelerators öğesini gpu_type olarak ve accelerator_type öğesini gpus olarak yeniden adlandırın ve yeni hızlandırıcı türü değerlerini kullanın. Eski argüman isimleri ve GPU tipi değerleri databricks.air içinde hâlâ çalışır, ancak bir FutureWarning üretir. Destek GPU ortamı sürüm 7'de sona erecek.

Tavsiye

Genie Code'a bunu sizin için gerçekleştirmesini söyleyin:

Migrate this notebook from the serverless_gpu SDK to the AI Runtime SDK.

databricks.air.data kullanan Databricks CLI iş yükleri için, iş yükünün databricks-sdk-air[data] öğesine environment.dependencies ekleyin.

TorchDistributor'dan geliyor

Eğer Spark kümelerinde TorchDistributor kullanarak dağıtık eğitim çalıştırıyorsanız ve iş yükünüz tek bir düğüme uyuyorsa, @distributed API, AI Çalışma Zamanında önerilen alternatiftir. DDP, FSDP veya DeepSpeed model kodunuz değişmiyor.

Feature	@distributed API (Uygulama Programlama Arayüzü)	TorchDistributor
Infrastructure	Tamamen sunucusuz, küme yönetimi yok	GPU çalışanlarıyla spark kümesi gerektirir
Ayarlama	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. Bunun yerine notebook'unuzu 8xH100 hızlandırıcıya bağlayın. @distributed varsayılan olarak sekiz GPU'nun tamamını kullanıyor.
• 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.

Dekoratör @distributedBeta aşamasında ve tek bir düğümde çalışır ( bkz. Sınırlamalar), yani 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 AI Çalışma Zamanı için Databricks CLI komutlarını kullanın. Bkz. Databricks CLI'yı AI Çalışma Zamanı ile Kullanın.

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. Dekoratörü distributed AI Runtime SDK'dan içe aktarın.

   from databricks.air 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()
   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-parallel 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 databricks.air import distributed

# Don't do this: loading the dataset outside the function means it's captured
# and pickled with the function, which can raise a pickle error.
# dataset = get_dataset(file_path)

@distributed()
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 databricks.air.data içinden kullanın. Dağıtılmış eğitimin denetim noktalarını bir depolama birimine kaydetmek için UCVolumeWriter ve UCVolumeReader kullanın. AI Runtime üzerinde veri yükleme ve Dağıtık Denetim Noktası (DCP) ile denetim noktası oluşturma konularına bkz.

Limitations

• @distributed Sadece tek bir düğümü destekler: notebook’unuzun bağlı olduğu düğümdeki GPU'lar arasında çalışır. Birden fazla düğüm üzerinde eğitmek için AI Runtime Databricks CLI'sını kullanın. Bkz. Databricks CLI'yı AI Çalışma Zamanı ile Kullanın.
• Eğer accelerator_type ayarlarsanız, defterinizin bağlı olduğu hızlandırıcıyla eşleşmelidir (örneğin, "GPU_8xH100"). 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 destekler. Ö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.

Ek kaynaklar

• AcceleratorType dekoratör, @distributed ve Ray API'leri için Databricks AI Runtime SDK API referansına bakın.
• 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 dağıtık eğitim örneklerine bakınız.