Kodunuza Accelerate ekleyin

Her dağıtık eğitim çerçevesinin, PyTorch eğitim kodunuza ve eğitim ortamınıza uyarlamak için çok fazla özel kod yazmayı gerektirebilecek kendine özgü çalışma yöntemleri vardır. Accelerate, her birinin spesifik detaylarını öğrenmek zorunda kalmadan bu dağıtık eğitim çerçeveleriyle etkileşime geçmenin kullanıcı dostu bir yolunu sunar. Accelerate bu detaylarla sizin yerinize ilgilenir, böylece eğitim koduna odaklanabilir ve onu herhangi bir dağıtık eğitim ortamına ölçeklendirebilirsiniz.

Bu eğitimde, mevcut PyTorch kodunuzu Accelerate ile nasıl uyarlayacağınızı ve dağıtık sistemlerde eğitimi kolayca başlatacağınızı öğreneceksiniz. Temel bir PyTorch eğitim döngüsüyle başlayacaksınız (bu döngü, model ve optimizer gibi tüm eğitim nesnelerinin zaten yapılandırıldığı varsayımına dayanır) ve Accelerate’yi buna kademeli olarak entegre edeceksiniz.

device = "cuda"
model.to(device)

for batch in training_dataloader:
    optimizer.zero_grad()
    inputs, targets = batch
    inputs = inputs.to(device)
    targets = targets.to(device)
    outputs = model(inputs)
    loss = loss_function(outputs, targets)
    loss.backward()
    optimizer.step()
    scheduler.step()

Hızlandırıcı

Accelerator, kodunuzu Accelerate ile çalışacak şekilde uyarlamak için kullanılan ana sınıftır. Kullandığınız dağıtık yapılandırma hakkında bilgiye sahiptir; örneğin farklı süreç sayısı ve donanım türünüz. Bu sınıf, PyTorch kodunuzun herhangi bir dağıtık eğitim ortamında çalışmasını sağlayan ve cihazlar arası süreçleri yönetip yürüten birçok gerekli yönteme erişim sağlar.

Bu nedenle, script'inizde her zaman bir Accelerator örneğini içe aktarıp oluşturarak başlamanız gerekir.

from accelerate import Accelerator

accelerator = Accelerator()

Accelerator, PyTorch nesnelerinizin hangi cihaza taşınacağını da bildiğinden, bu işlemin Accelerate tarafından sizin için yönetilmesini öneririz.

- device = "cuda"
+ device = accelerator.device
  model.to(device)

PyTorch nesnelerini hazırlayın

Ardından, PyTorch nesnelerinizi (model, optimizer, scheduler vb.) dağıtık eğitim için hazırlamanız gerekir. prepare() metodu, eğitim kurulumunuz için modelinizi uygun kapsayıcıya (tek GPU veya çoklu GPU gibi) yerleştirmek, optimizer ve scheduler’ı Accelerate’in AcceleratedOptimizer ve AcceleratedScheduler sınıflarını kullanacak şekilde uyarlamak ve süreçler arasında paylaştırılabilecek yeni bir dataloader oluşturmakla ilgilenir.

Accelerate yalnızca torch.optim.Optimizer gibi ilgili PyTorch sınıflarından türeyen nesneleri hazırlar.

PyTorch nesneleri, gönderildikleri sırayla döndürülür.

model, optimizer, training_dataloader, scheduler = accelerator.prepare(
    model, optimizer, training_dataloader, scheduler
)

Eğitim döngüsü

Son olarak, eğitim döngüsündeki girdi ve hedeflere yönelik to(device) çağrılarını kaldırın çünkü Accelerate’in DataLoader sınıfları bunları otomatik olarak doğru cihaza yerleştirir. Ayrıca, normal backward() geçişini, dağıtık kurulumunuza (örneğin DeepSpeed veya Megatron) göre uygun backward() yöntemini kullanan ve gradyanları sizin için ölçekleyen Accelerate’in backward() yöntemiyle değiştirmelisiniz.

-   inputs = inputs.to(device)
-   targets = targets.to(device)
    outputs = model(inputs)
    loss = loss_function(outputs, targets)
-   loss.backward()
+   accelerator.backward(loss)

Her şeyi bir araya getirin ve yeni Accelerate eğitim döngünüz artık şöyle görünmelidir!

from accelerate import Accelerator
accelerator = Accelerator()

device = accelerator.device
model, optimizer, training_dataloader, scheduler = accelerator.prepare(
    model, optimizer, training_dataloader, scheduler
)

for batch in training_dataloader:
    optimizer.zero_grad()
    inputs, targets = batch
    outputs = model(inputs)
    loss = loss_function(outputs, targets)
    accelerator.backward(loss)
    optimizer.step()
    scheduler.step()

Eğitim özellikleri

Accelerate, eğitim çalışmanızı iyileştirmek için scriptinize ekleyebileceğiniz ek özellikler sunar - örneğin gradyan biriktirme, gradyan kırpma, karma hassasiyetli eğitim ve daha fazlası. Gelin bu üç özelliği inceleyelim.

Gradient biriktirme

Gradient accumulation, ağırlıkların güncellenmesinden önce birden çok batch üzerinde gradyanların biriktirilmesine olanak tanıyarak daha büyük batch boyutlarında eğitim yapmanızı sağlar. Bu, bellek kısıtlamalarının aşılmasında faydalı olabilir. Bu özelliği Accelerate'ta etkinleştirmek için Accelerator sınıfında gradient_accumulation_steps parametresini belirtin ve scriptinize accumulate() bağlam yöneticisini ekleyin.

+ accelerator = Accelerator(gradient_accumulation_steps=2)
  model, optimizer, training_dataloader = accelerator.prepare(model, optimizer, training_dataloader)

  for input, label in training_dataloader:
+     with accelerator.accumulate(model):
          predictions = model(input)
          loss = loss_function(predictions, label)
          accelerator.backward(loss)
          optimizer.step()
          scheduler.step()
          optimizer.zero_grad()

Gradient kırpma

Gradient clipping, “patlayan gradyanları” önlemek için kullanılan bir tekniktir ve Accelerate şunları sunar:

• Gradyanları bir minimum ve maksimum değere kırpma için clipgrad_value()
• Gradyanları belirli bir değere normalize etmek için clipgrad_norm()

Karışık hassasiyet

Karışık hassasiyet, fp16 (yarım hassasiyet) gibi daha düşük hassasiyetli bir veri türü kullanarak gradyanları hesaplamak suretiyle eğitimi hızlandırır. Accelerate ile en iyi performansı elde etmek için, modelin dışındaki hesaplamalar tam hassasiyetle yapıldığından, kayıp (loss) modelin içinde hesaplanmalıdır (örneğin Transformers modellerinde olduğu gibi).

Accelerator içinde kullanılacak karma hassasiyet türünü ayarlayın ve ardından autocast() bağlam yöneticisini kullanarak değerleri belirtilen veri türüne otomatik olarak dönüştürün.

Accelerate otomatik karma hassasiyeti (automatic mixed precision) etkinleştirir, bu nedenle autocast() yalnızca, backward() tarafından zaten ölçeklendirme işlemiyle ele alınan kayıp (loss) üzerindeki işlemlerin dışında başka karma hassasiyet işlemleri varsa gereklidir.

+ accelerator = Accelerator(mixed_precision="fp16")
+ with accelerator.autocast():
      loss = complex_loss_function(outputs, target)

Kaydet ve yükle

Accelerate, eğitim tamamlandıktan sonra bir model kaydedip yükleyebilir veya eğitimden devam etmek için faydalı olabilecek model ve optimizör state bilgilerini de kaydedebilirsiniz.

Model

Tüm işlemler tamamlandıktan sonra, modeli kaydetmeden önce prepare() yöntemi modelinizi dağıtık eğitim için uygun arayüze sardığından, modeli unwrap_model() yöntemiyle sarmalardan çıkarın. Modeli sarmaldan çıkarmazsanız, model durum sözlüğünü kaydetmek, daha büyük modelden kaynaklanan olası ek katmanları da kaydeder ve ağırlıkları temel modelinize geri yükleyemezsiniz.

Model durum sözlüğünü sarmalayıp kaydetmek için save_model() metodunu kullanmalısınız. Bu yöntem, modeli ayrıca parçalı denetim noktalarına veya safetensors biçimine de kaydedebilir.

accelerator.wait_for_everyone()
accelerator.save_model(model, save_directory)

unwrapped_model = accelerator.unwrap_model(model)
path_to_checkpoint = os.path.join(save_directory,"pytorch_model.bin")
unwrapped_model.load_state_dict(torch.load(path_to_checkpoint))

accelerator.wait_for_everyone()
accelerator.save_model(model, save_directory, max_shard_size="1GB", safe_serialization=True)

load_checkpoint_in_model(unwrapped_model, save_directory, device_map={"":device})

Durum

Eğitim sırasında, modelin, optimizasyoncunun, rastgele üreteçlerin ve potansiyel olarak öğrenme oranı zamanlayıcılarının mevcut durumunu, aynı betikte geri yüklenebilmeleri için kaydetmek isteyebilirsiniz. Durumları kaydetmek ve yüklemek için betiğinize save_state() ve load_state() yöntemlerini eklemelisiniz.

save_state() ile durumların nerede ve nasıl kaydedileceğini daha da özelleştirmek için ProjectConfiguration sınıfını kullanın. Örneğin, automatic_checkpoint_naming etkinse, her kaydedilen checkpoint Accelerator.project_dir/checkpoints/checkpoint_{checkpoint_number} konumunda saklanır.

Kaydedilmesi ve yüklenmesi gereken diğer durumlu öğeler, register_for_checkpointing() yöntemiyle kaydedilmelidir. Bu yönteme kaydedilmek üzere iletilen her nesnenin bir load_state_dict ve state_dict fonksiyonu bulunmalıdır.

torchdata>=0.8.0 yüklüyse, DataLoaderConfiguration nesnenize ek olarak use_stateful_dataloader=True parametresini de iletebilirsiniz. Bu, Accelerate’in DataLoader sınıflarını load_state_dict ve state_dict fonksiyonlarıyla genişletir ve model kalıcılaştırılırken Accelerator.save_state ile Accelerator.load_state fonksiyonlarının eğitim veri setinde ne kadar ilerlendiğini de takip etmesini sağlar.