Accelerate documentation

Hızlandırıcı

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Hızlandırıcı

Accelerator, her türlü eğitim kurulumunda dağıtık eğitimi etkinleştirmek için ana sınıftır. Accelerator'yi scriptinize nasıl ekleyeceğinizi öğrenmek için Accelerator'ı kodunuza ekleme eğitimine göz atın.

Hızlandırıcı

sınıf accelerate.Accelerator

< >

( device_placement: bool = Truesplit_batches: bool = <object object at 0x7f7bf6a755a0>mixed_precision: PrecisionType | str | None = Nonegradient_accumulation_steps: int = 1cpu: bool = Falsedataloader_config: DataLoaderConfiguration | None = Nonedeepspeed_plugin: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None = Nonefsdp_plugin: FullyShardedDataParallelPlugin | None = Nonetorch_tp_plugin: TorchTensorParallelPlugin | None = Nonemegatron_lm_plugin: MegatronLMPlugin | None = Nonerng_types: list[str | RNGType] | None = Nonelog_with: str | LoggerType | GeneralTracker | list[str | LoggerType | GeneralTracker] | None = Noneproject_dir: str | os.PathLike | None = Noneproject_config: ProjectConfiguration | None = Nonegradient_accumulation_plugin: GradientAccumulationPlugin | None = Nonestep_scheduler_with_optimizer: bool = Truekwargs_handlers: list[KwargsHandler] | None = Nonedynamo_backend: DynamoBackend | str | None = Nonedynamo_plugin: TorchDynamoPlugin | None = Nonedeepspeed_plugins: DeepSpeedPlugin | dict[str, DeepSpeedPlugin] | None = Noneparallelism_config: ParallelismConfig | None = None )

Parametreler

  • device_placement (bool, isteğe bağlı, varsayılan True) — Hızlandırıcının nesneleri cihaza (dataloader tarafından üretilen tensörler, model vb.) yerleştirip yerleştirmeyeceği.
  • mixed_precision (str, isteğe bağlı) — Karışık hassasiyetli eğitim kullanılıp kullanılmayacağını belirtir. ‘no’,‘fp16’,‘bf16’ veya ‘fp8’ değerlerinden birini seçin. Varsayılan olarak ortam değişkenindeki ACCELERATE_MIXED_PRECISION değerini kullanır; bu da mevcut sistemin accelerate yapılandırmasındaki varsayılan değeri veya accelerate.launch komutuyla geçirilen bayrağı kullanır. ‘fp8’, transformers-engine kurulumunu gerektirir.
  • gradient_accumulation_steps (int, isteğe bağlı, varsayılan 1) — Gradyanların birikmesi için geçmesi gereken adım sayısı. 1'den büyük bir sayı, Accelerator.accumulate ile birlikte kullanılmalıdır. Verilmezse, ACCELERATE_GRADIENT_ACCUMULATION_STEPS ortam değişkenindeki değere varsayılan olarak ayarlanır. Ayrıca bir GradientAccumulationPlugin üzerinden yapılandırılabilir.
  • cpu (bool, isteğe bağlı) — Betiklerin CPU üzerinde çalıştırılmasını zorunlu kılıp kılmayacağı. True olarak ayarlanırsa mevcut GPU yok sayılır ve çalıştırma yalnızca bir süreçte zorlanır.
  • dataloader_config (DataLoaderConfiguration, isteğe bağlı) — Dağıtık senaryolarda dataloader'ların nasıl ele alınacağına dair bir yapılandırma.
  • deepspeed_plugin (DeepSpeedPlugin veya str — DeepSpeedPlugin sözlüğü, isteğe bağlı): DeepSpeed ile ilgili argümanlarınızı bu argüman aracılığıyla ayarlayın. Bu argüman isteğe bağlıdır ve accelerate config kullanılarak doğrudan yapılandırılabilir. Birden fazla eklenti kullanıyorsanız, her eklentinin yapılandırılmış key özelliğini kullanarak onlara accelerator.state.get_deepspeed_plugin(key) üzerinden erişin. deepspeed_plugins için takma ad.
  • fsdp_plugin (FullyShardedDataParallelPlugin, isteğe bağlı) — FSDP ile ilgili argümanlarınızı bu argüman aracılığıyla ayarlayın. Bu argüman isteğe bağlıdır ve doğrudan accelerate config kullanılarak yapılandırılabilir.
  • torch_tp_plugin (TorchTensorParallelPlugin, isteğe bağlı) — Kullanımı durduruldu: bunun yerine parallelism_config ile tp_size kullanın.
  • megatron_lm_plugin (MegatronLMPlugin, isteğe bağlı) — MegatronLM ile ilgili argümanlarınızı bu argüman aracılığıyla ayarlayın. Bu argüman isteğe bağlıdır ve accelerate config kullanılarak doğrudan yapılandırılabilir.
  • rng_types (liste str veya RNGType) — Hazırlanmış dataloader'larınızda her iterasyonun başında senkronize edilecek rastgele sayı üreteçlerinin listesi. Şunlardan biri veya birkaçı olmalıdır:
    • "torch": temel torch rastgele sayı üreteci
    • "cuda": CUDA rastgele sayı üreteci (yalnızca GPU)
    • Kayıtlı herhangi bir PyTorch hızlandırıcısının cihaz türü: cihaz rastgele sayı üreteci.
    • "xla": XLA rastgele sayı üreteci (yalnızca TPU)
    • "generator": altta yatan veri seti bu türdeyse, örnekleyicinin (dataloader'ınızda örnekleyici yoksa batch örnekleyicinin) veya yinelebilir veri setinin (varsa) torch.Generator'ı.

    PyTorch sürümleri <=1.5.1 için varsayılan olarak ["torch"], >= 1.6 sürümleri için ["generator"] olacaktır.

  • log_with (liste str, LoggerType veya GeneralTracker, isteğe bağlı) — Deneysel izleme için kurulacak kayıtçılar listesi. Şunlardan biri veya birkaçı olmalıdır:
    • "all"
    • "tensorboard"
    • "wandb"
    • "trackio"
    • "aim"
    • "comet_ml"
    • "mlflow"
    • "dvclive"
    • "swanlab" "all" seçilirse, ortamda mevcut olan tüm izleyiciler seçilir ve başlatılır. Özel izleyiciler için GeneralTracker uygulamalarını da kabul edebilir ve "all" ile birleştirilebilir.
  • project_config (ProjectConfiguration, isteğe bağlı) — Durumun nasıl kaydedileceğini belirleyen bir yapılandırma.
  • project_dir (str, os.PathLike, isteğe bağlı) — Yerel olarak uyumlu kayıt tutucuların günlükleri ve potansiyel olarak kaydedilen denetim noktaları gibi verilerin saklanması için bir dizine giden yol.
  • step_scheduler_with_optimizer (bool, isteğe bağlı, varsayılan True) — Öğrenme hızı zamanlayıcısı, optimizörle aynı anda adım atıyorsa True, yalnızca belirli koşullar altında (örneğin her dönemin sonunda) yapılıyorsa False olarak ayarlayın.
  • kwargs_handlers (KwargsHandler listesi, isteğe bağlı) — Dağıtık eğitim, profilleme veya karma hassasiyet ile ilgili nesnelerin nasıl oluşturulacağını özelleştirmek için bir KwargsHandler listesi. Daha fazla bilgi için kwargs bölümüne bakın.
  • dynamo_backend (str veya DynamoBackend, isteğe bağlı, varsayılan "no") — Eğitiminizi torch dynamo ile optimize etmek için olası dynamo backend'lerinden birine ayarlayın.
  • dynamo_plugin (TorchDynamoPlugin, isteğe bağlı) — Sadece backend veya mode ayarlamasıyla yetinilmeyip daha fazla ince ayar gerekiyorsa, torch dynamo'nun nasıl ele alınacağına dair yapılandırma.
  • gradient_accumulation_plugin (GradientAccumulationPlugin, isteğe bağlı) — Sadece gradient_accumulation_steps ile yetinmeyip daha fazla ayar gerektiren durumlarda, gradyan biriktirmenin nasıl ele alınacağına dair bir yapılandırma.

Dağıtık eğitim veya karma hassasiyet eğitimi için bir hızlandırıcı örneği oluşturur.

Kullanılabilir öznitelikler:

  • device (torch.device) — Kullanılacak cihaz.
  • distributed_type (DistributedType) — Dağıtık eğitim yapılandırması.
  • local_process_index (int) — Güncel makinedeki süreç indeksi.
  • mixed_precision (str) — Yapılandırılmış karma hassasiyet modu.
  • num_processes (int) — Eğitim için kullanılan toplam süreç sayısı.
  • optimizer_step_was_skipped (bool) — Optimizer güncellemesinin atlanıp atlanmadığı (karışık hassasiyette gradyan taşması nedeniyle), bu durumda öğrenme hızının değiştirilmemesi gerekir.
  • process_index (int) — Tüm süreçler arasındaki mevcut sürecin genel indeksi.
  • state (AcceleratorState) — Dağıtık kurulum durumu.
  • sync_gradients (bool) — Gradyanların şu anda tüm süreçler arasında senkronize edilip edilmediğini belirtir.
  • use_distributed (bool) — Geçerli yapılandırmanın dağıtık eğitim için olup olmadığı.

accumulate

< >

( *models )

Parametreler

  • *models (torch.nn.Module listesi) — Accelerator.prepare ile hazırlanmış PyTorch modülleri. accumulate() fonksiyonuna geçirilen modeller, dağıtık eğitim sırasında geri yayılım (backward pass) sırasında gradyan senkronizasyonunu atlar.

Hafifçe sarmalayarak otomatik olarak gradyan biriktirme (gradient accumulation) işlemini gerçekleştiren bir bağlam yöneticisi (context manager)

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(gradient_accumulation_steps=1)
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)

>>> for input, output in dataloader:
...     with accelerator.accumulate(model):
...         outputs = model(input)
...         loss = loss_func(outputs)
...         loss.backward()
...         optimizer.step()
...         scheduler.step()
...         optimizer.zero_grad()

autocast

< >

( autocast_handler: AutocastKwargs = None )

Bu bağlam yöneticisi içindeki blok içinde, etkinleştirilmişse otomatik karma hassasiyeti (automatic mixed-precision) uygulanır. Aksi takdirde farklı bir işlem gerçekleşmez.

autocast_handler olarak farklı bir değer geçirilerek Accelerator nesnesinde ayarlanan değer geçersiz kılınabilir. Bu, autocast blokları altında fp32'ye geri dönmek istediğiniz durumlarda kullanışlıdır.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(mixed_precision="fp16")
>>> with accelerator.autocast():
...     train()

geriye yayılım

< >

( loss**kwargs )

Gradyanları GradientAccumulationPlugin ile uyumlu olarak ölçekler ve yapılandırmaya göre doğru backward() çağrısını yapar.

loss.backward() yerine kullanılmalıdır.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(gradient_accumulation_steps=2)
>>> outputs = model(inputs)
>>> loss = loss_fn(outputs, labels)
>>> accelerator.backward(loss)

check_trigger

< >

( )

İç tetikleyici tensörünün herhangi bir işlemde 1 olarak ayarlanıp ayarlanmadığını kontrol eder. Eğer öyleyse, True döndürür ve tetikleyici tensörünü 0 olarak sıfırlar.

Not: wait_for_everyone() gerektirmez

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume later in the training script
>>> # `should_do_breakpoint` is a custom function to monitor when to break,
>>> # e.g. when the loss is NaN
>>> if should_do_breakpoint(loss):
...     accelerator.set_trigger()
>>> # Assume later in the training script
>>> if accelerator.check_trigger():
...     break

temizle

< >

( *objects )

Accelerate.free_memory için bir takma adıdır; depolanan iç nesnelere yönelik tüm referansları serbest bırakır ve çöp toplayıcıyı çağırır. Farklı modeller/optimizatörlerle iki eğitim arasında bu yöntemi çağırmanız gerekir.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, scheduler = ...
>>> model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)
>>> model, optimizer, scheduler = accelerator.clear(model, optimizer, scheduler)

clip_grad_norm_

< >

( parametersmax_normnorm_type = 2 ) → torch.Tensor

Dönüş değeri

torch.Tensor

Parametre gradyanlarının toplam normu (tek bir vektör olarak ele alındığında).

torch.nn.utils.clip_grad_norm_ yerine kullanılmalıdır.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(gradient_accumulation_steps=2)
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)

>>> for input, target in dataloader:
...     optimizer.zero_grad()
...     output = model(input)
...     loss = loss_func(output, target)
...     accelerator.backward(loss)
...     if accelerator.sync_gradients:
...         accelerator.clip_grad_norm_(model.parameters(), max_grad_norm)
...     optimizer.step()

clip_grad_value_

< >

( parametersclip_value )

torch.nn.utils.clip_grad_value_ yerine kullanılmalıdır.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(gradient_accumulation_steps=2)
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)

>>> for input, target in dataloader:
...     optimizer.zero_grad()
...     output = model(input)
...     loss = loss_func(output, target)
...     accelerator.backward(loss)
...     if accelerator.sync_gradients:
...         accelerator.clip_grad_value_(model.parameters(), clip_value)
...     optimizer.step()

deepspeed_ulysses_dl_adapter

< >

( dlmodel )

bu, normalde prepare parçası olarak çağrılır ancak dataloader, modelden ayrı olarak hazırlandığında (dış accelerator.prepare çağrısı için) bu ek çağrı, prepare(model) sonrasında yapılmalıdır (kullanım senaryosu olarak HF Trainer'a bakın)

end_training

< >

( )

Deney izleme kullanılıyorsa, betiğinizin sonunda her zaman çağrılmalıdır. Ana süreçte yalnızca izleyicileri durdurma veya süreç grubunu yok etme gibi özel eğitim sonu davranışlarını çalıştırır.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(log_with="tensorboard")
>>> accelerator.init_trackers("my_project")
>>> # Do training
>>> accelerator.end_training()

free_memory

< >

( *objects )

Dahili nesneler için tutulan tüm referansları bırakır ve çöp toplayıcıyı çağırır. Farklı modeller/optimizatörlerle iki eğitim arasında bu yöntemi çağırmalısınız. Ayrıca Accelerator.step değerini 0 olarak sıfırlar.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, scheduler = ...
>>> model, optimizer, scheduler = accelerator.prepare(model, optimizer, scheduler)
>>> model, optimizer, scheduler = accelerator.free_memory(model, optimizer, scheduler)

topla

< >

( tensor ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor

Parametreler

  • tensor (torch.Tensor veya torch.Tensor içeren iç içe geçmiş bir tuple/list/dictionary) — Tüm süreçler arasında toplanacak tensörler.

Dönüş değeri

torch.Tensor veya torch.Tensor içeren iç içe geçmiş bir tuple/list/dictionary

Toplanan tensör(ler). Sonucun ilk boyutunun, girdi tensörlerinin ilk boyutunun num_processes ile çarpımı olduğunu unutmayın.

tensor içindeki değerleri tüm süreçler arasında toplayın ve birinci boyutta birleştirin. Değerlendirme yapılırken tüm süreçlerden gelen tahminleri yeniden gruplamak için kullanışlıdır.

Not: Bu toplama işlemi tüm süreçlerde gerçekleşir.

Örnek:

>>> # Assuming four processes
>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> process_tensor = torch.tensor([accelerator.process_index], device=accelerator.device)
>>> gathered_tensor = accelerator.gather(process_tensor)
>>> gathered_tensor
tensor([0, 1, 2, 3])

gather_for_metrics

< >

( input_datause_gather_object = False )

Parametreler

  • input_data (torch.Tensor, object, torch.Tensor içeren iç içe geçmiş bir tuple/list/dictionary veya object içeren iç içe geçmiş bir tuple/list/dictionary) — Tüm süreçler arasında metrik hesaplamak için kullanılan tensörler veya nesneler
  • use_gather_object(bool) — Tüm nesneler tensör içermiyorsa zaten yapılan) gather yerine gather_object'ı zorla kullanıp kullanmayacağı. Bu bayrak, birinci boyut boyunca doldurmak ve birleştirmek istemediğimiz farklı boyutlarda tensörleri toplamak için faydalı olabilir. GPU tensörleriyle kullanımı iyi desteklenmez ve verimsizdir, çünkü tensörler pickle'lanacağı için GPU -> CPU aktarımı gerektirir.

Dağıtık bir sistemdeyse son partideki input_data değerlerini toplar ve olası kopyaları atar. Metrik hesaplama için girdilerin ve hedeflerin toplanması amacıyla kullanılmalıdır.

Örnek:

>>> # Assuming two processes, with a batch size of 5 on a dataset with 9 samples
>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> dataloader = torch.utils.data.DataLoader(range(9), batch_size=5)
>>> dataloader = accelerator.prepare(dataloader)
>>> batch = next(iter(dataloader))
>>> gathered_items = accelerator.gather_for_metrics(batch)
>>> len(gathered_items)
9

get_state_dict

< >

( modelunwrap = True ) → dict

Parametreler

  • model (torch.nn.Module) — Accelerator.prepare() üzerinden gönderilen bir PyTorch modeli
  • unwrap (bool, isteğe bağlı, varsayılan True) — model'in orijinal alt yatan state_dict'ini mi yoksa sarılmış state_dict'ini mi döndürüleceğini belirtir

Dönüş değeri

dict

Modelin tam hassasiyette olmayabilecek durum sözlüğü.

Accelerator.prepare() üzerinden gönderilen bir modelin durum sözlüğünü, tam hassasiyet olmadan döndürür.

Örnek:

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> net = torch.nn.Linear(2, 2)
>>> net = accelerator.prepare(net)
>>> state_dict = accelerator.get_state_dict(net)

get_tracker

< >

( name: strunwrap: bool = False ) → GeneralTracker

Parametreler

  • name (str) — Bir izleyicinin adı, .name özelliğine karşılık gelir.
  • unwrap (bool) — Dahili izleme mekanizmasının mı yoksa sarılmış izleyicinin mi (önerilen) döndürüleceğini belirtir

Dönüş değeri

GeneralTracker

Eğer varsa name'e karşılık gelen izleyici.

Yalnızca ana işlemde, name değerine göre self.trackers içinden bir tracker döndürür.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(log_with="tensorboard")
>>> accelerator.init_trackers("my_project")
>>> tensorboard_tracker = accelerator.get_tracker("tensorboard")

join_uneven_inputs

< >

( joinableseven_batches = None )

Parametreler

  • joinables (list[torch.distributed.algorithms.Joinable]) — torch.distributed.algorithms.Joinable alt sınıfı olan modellerin veya optimizörlerin listesi. En yaygın olarak, DistributedDataParallel eğitimi için Accelerator.prepare ile hazırlanmış bir PyTorch Module'dir.
  • even_batches (bool, isteğe bağlı) — Ayarlanırsa, Accelerator içinde ayarlanan even_batches değerinin üzerine yazar. Sağlanmazsa, varsayılan Accelerator değeri kullanılır.

Eşit olmayan girdiler üzerinde dağıtık eğitim veya değerlendirme kolaylaştıran, torch.distributed.algorithms.join etrafında bir sarmalayıcı olarak çalışan bir bağlam yöneticisi. Toplu boyutun veri setinin uzunluğuna tam olarak bölünmediği durumlarda kullanışlıdır.

join_uneven_inputs yalnızca birden çok GPU üzerinde Distributed Data Parallel eğitimini destekler. Diğer herhangi bir yapılandırmada bu yöntemin bir etkisi olmaz.

even_batches'in geçersiz kılınması, yinelebilir (iterable) tarzı veri yükleyicilerini etkilemez.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator(even_batches=True)
>>> ddp_model, optimizer, dataloader = accelerator.prepare(model, optimizer, dataloader)

>>> with accelerator.join_uneven_inputs([ddp_model], even_batches=False):
...     for input, output in dataloader:
...         outputs = model(input)
...         loss = loss_func(outputs)
...         loss.backward()
...         optimizer.step()
...         optimizer.zero_grad()

load_state

< >

( input_dir: str | None = Noneload_kwargs: dict | None = None**load_model_func_kwargs )

Parametreler

  • input_dir (str veya os.PathLike) — Tüm ilgili ağırlıkların ve durumların kaydedildiği klasörün adı. automatic_checkpoint_naming kullanılıyorsa None olabilir ve en son kontrol noktasından devam eder.
  • load_kwargs (dict, isteğe bağlı) — state_dict ve optimizer için isteğe bağlı argümanlar gibi, alttaki load fonksiyonu için ek anahtar kelime argümanları.
  • load_model_func_kwargs (dict, isteğe bağlı) — Altta yatan yükleme işlevine aktarılabilecek, modelin yüklenmesi için ek anahtar kelime argümanları, örneğin DeepSpeed'in load_checkpoint işlevi için isteğe bağlı argümanlar veya modelin ve optimizasyonun yükleneceği map_location.

Modelin, optimizasyoncunun, ölçeklendiricinin, RNG üreteçlerinin ve kayıtlı nesnelerin mevcut durumlarını yükler.

Yalnızca Accelerator.save_state() ile birlikte kullanılmalıdır. Bir dosya checkpoint için kayıtlı değilse, dizinde saklanıyor olsa bile yüklenmez.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, lr_scheduler = ...
>>> model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
>>> accelerator.load_state("my_checkpoint")

local_main_process_first

< >

( )

Yerel ana sürecin bir with bloğunun içine girmesini sağlar.

Diğer süreçler, ana süreç çıktığında with bloğuna girecektir.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> with accelerator.local_main_process_first():
...     # This will be printed first by local process 0 then in a seemingly
...     # random order by the other processes.
...     print(f"This will be printed by process {accelerator.local_process_index}")

lomo_backward

< >

( loss: torch.Tensorlearning_rate: float )

LOMO optimizörlerinde geriye yayılımı çalıştırır.

main_process_first

< >

( )

Bir with bloğu içinde ana sürecin önce gitmesine izin verir.

Diğer süreçler, ana süreç çıktığında with bloğuna girecektir.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> with accelerator.main_process_first():
...     # This will be printed first by process 0 then in a seemingly
...     # random order by the other processes.
...     print(f"This will be printed by process {accelerator.process_index}")

belki_context_parallel

< >

( buffers: list[torch.Tensor] | None = Nonebuffer_seq_dims: list[int] | None = Noneno_restore_buffers: set[torch.Tensor] | None = None )

Parametreler

  • buffers (list[torch.Tensor], optional) — Sıralama boyutu boyunca parçalanacak tamponlar. Yaygın örnekler girdiler, etiketler veya konumsal gömme tamponlarıdır. Bu bağlam yöneticisi bu tamponları yerinde (in-place) değiştirecek ve bağlamdan çıkıldıktan sonra tamponlar orijinal durumlarına geri yüklenecektir. Gereksiz geri yüklemelerden kaçınmak için, geri yüklenmesi gerekmeyen tamponları belirtmek için no_restore_buffers kullanabilirsiniz.
  • buffer_seq_dims (list[int], optional) — buffers dizilerinin boyutları.
  • no_restore_buffers (set[torch.Tensor], optional) — Bu küme, buffers'un bir alt kümesi olmalıdır. Bağlam çıkışından sonra buffers argümanındaki hangi tamponların geri yüklenmeyeceğini belirtir. Bu tamponlar daha sonra parçalı (sharded) durumda tutulur.

Bağlam paralel eğitimini etkinleştiren bir bağlam yöneticisi.

context_parallel şu anda FSDP2 ile desteklenmektedir ve parallelism_config.cp_size >

  1. Bu koşullardan herhangi biri sağlanmazsa, bu bağlam yöneticisi hiçbir etki göstermez; ancak daha az kod değişikliği gerektirmek için bir Exception fırlatmaz.

Bu bağlam yöneticisi, aşağıdaki örnekte gösterildiği gibi her eğitim adımıyla yeniden oluşturulmalıdır.

Örnek:

>>> for batch in dataloader:
...     with accelerator.maybe_context_parallel(
...         buffers=[batch["input_ids"], batch["attention_mask"]],
...         buffer_seq_dims=[1, 1],
...         no_restore_buffers={batch["input_ids"]},
...     ):
...         outputs = model(batch)
...         ...

no_sync

< >

( model )

Parametreler

  • model (torch.nn.Module) — Accelerator.prepare ile hazırlanmış bir PyTorch Module

torch.nn.parallel.DistributedDataParallel.no_sync çağrılarak DDP süreçleri arasında gradyan senkronizasyonlarını devre dışı bırakmak için bir bağlam yöneticisi.

model DDP içinde değilse, bu bağlam yöneticisi hiçbir şey yapmaz

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)
>>> input_a = next(iter(dataloader))
>>> input_b = next(iter(dataloader))

>>> with accelerator.no_sync():
...     outputs = model(input_a)
...     loss = loss_func(outputs)
...     accelerator.backward(loss)
...     # No synchronization across processes, only accumulate gradients
>>> outputs = model(input_b)
>>> accelerator.backward(loss)
>>> # Synchronization across all processes
>>> optimizer.step()
>>> optimizer.zero_grad()

on_last_process

< >

( function: Callable[..., Any] )

Parametreler

  • function (Callable) — Süslenmek üzere olan işlev.

Sadece son işlemde (process) süslenmiş (decorated) işlevi çalıştıracak bir süsleyici (decorator). PartialState sınıfı kullanılarak da çağrılabilir.

Örnek:

# Assume we have 4 processes.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_last_process
def print_something():
    print(f"Printed on process {accelerator.process_index}")


print_something()
"Printed on process 3"

on_local_main_process

< >

( function: Callable[..., Any] | None = None )

Parametreler

  • function (Callable) — Süslenmek üzere olan işlev.

Sadece yerel ana süreçte süslenmiş işlevi çalıştıracak bir süsleyici. PartialState sınıfı kullanılarak da çağrılabilir.

Örnek:

# Assume we have 2 servers with 4 processes each.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_local_main_process
def print_something():
    print("This will be printed by process 0 only on each server.")


print_something()
# On server 1:
"This will be printed by process 0 only"
# On server 2:
"This will be printed by process 0 only"

on_local_process

< >

( function: Callable[..., Any] | None = Nonelocal_process_index: int | None = None )

Parametreler

  • function (Callable, isteğe bağlı) — Süslenmesi gereken işlev.
  • local_process_index (int, isteğe bağlı) — Fonksiyonun çalıştırılacağı yerel sürecin indeksi.

Sadece verilen yerel süreç indeksinde dekore edilen fonksiyonu çalıştıracak bir dekoratör. PartialState sınıfı kullanılarak da çağrılabilir.

Örnek:

# Assume we have 2 servers with 4 processes each.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_local_process(local_process_index=2)
def print_something():
    print(f"Printed on process {accelerator.local_process_index}")


print_something()
# On server 1:
"Printed on process 2"
# On server 2:
"Printed on process 2"

on_main_process

< >

( function: Callable[..., Any] | None = None )

Parametreler

  • function (Callable) — Süslenmek üzere olan işlev.

Sadece ana süreçte süslenmiş işlevi çalıştıracak bir süsleyici. PartialState sınıfı kullanılarak da çağrılabilir.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()


>>> @accelerator.on_main_process
... def print_something():
...     print("This will be printed by process 0 only.")


>>> print_something()
"This will be printed by process 0 only"

on_process

< >

( function: Callable[..., Any] | None = Noneprocess_index: int | None = None )

Parametreler

  • function (Callable, optional) — Süslenmesi (decorate) gereken işlev.
  • process_index (int, optional) — Fonksiyonun çalıştırılacağı sürecin indeksi.

Belirli bir süreç indeksinde yalnızca süslenmiş işlevi çalıştıracak bir süsleyici. PartialState sınıfı kullanılarak da çağrılabilir.

Örnek:

# Assume we have 4 processes.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_process(process_index=2)
def print_something():
    print(f"Printed on process {accelerator.process_index}")


print_something()
"Printed on process 2"

pad_across_processes

< >

( tensordim = 0pad_index = 0pad_first = False ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor

Parametreler

  • tensor (iç içe list/tuple/dictionary of torch.Tensor) — Toplanacak veri.
  • dim (int, isteğe bağlı, varsayılan 0) — Doldurma yapılacak boyut.
  • pad_index (int, isteğe bağlı, varsayılan 0) — Doldurma için kullanılacak değer.
  • pad_first (bool, isteğe bağlı, varsayılan False) — Başta mı sonda mı dolgu yapılacağı.

Dönüş değeri

torch.Tensor veya torch.Tensor içeren iç içe geçmiş bir tuple/list/dictionary

Dolgulu tensör(ler).

Tüm cihazlardaki iç içe geçmiş liste/tuple/sözlük yapısındaki tensörleri, güvenli bir şekilde toplanabilmeleri için aynı boyuta kadar özyinelemeli olarak dolgu (padding) ile doldurun.

Örnek:

>>> # Assuming two processes, with the first processes having a tensor of size 1 and the second of size 2
>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> process_tensor = torch.arange(accelerator.process_index + 1).to(accelerator.device)
>>> padded_tensor = accelerator.pad_across_processes(process_tensor)
>>> padded_tensor.shape
torch.Size([2])

prepare

< >

( *argsdevice_placement = None )

Parametreler

  • *args (liste of objects) — Aşağıdaki nesne türlerinden herhangi biri:
    • torch.utils.data.DataLoader: PyTorch veri yükleyicisi
    • torch.nn.Module: PyTorch Modülü
    • torch.optim.Optimizer: PyTorch Optimizer
    • torch.optim.lr_scheduler.LRScheduler: PyTorch LR Zamanlayıcısı
  • device_placement (list[bool], isteğe bağlı) — Her bir nesne için otomatik cihaz yerleşiminin yapılıp yapılmayacağını özelleştirmek için kullanılır. args ile aynı uzunlukta bir liste olmalıdır. DeepSpeed veya FSDP ile uyumlu değildir.

args içinde geçen tüm nesneleri dağıtık eğitim ve karma hassasiyet için hazırlayın, ardından bunları aynı sırada döndürün.

Sadece karma hassasiyet türü olmadan çıkarım için bir model kullanıyorsanız, modeli hazırlamanıza gerek yoktur

Örnekler:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume a model, optimizer, data_loader and scheduler are defined
>>> model, optimizer, data_loader, scheduler = accelerator.prepare(model, optimizer, data_loader, scheduler)
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume a model, optimizer, data_loader and scheduler are defined
>>> device_placement = [True, True, False, False]
>>> # Will place the first two items passed in automatically to the right device but not the last two.
>>> model, optimizer, data_loader, scheduler = accelerator.prepare(
...     model, optimizer, data_loader, scheduler, device_placement=device_placement
... )

prepare_data_loader

< >

( data_loader: torch.utils.data.DataLoaderdevice_placement = Noneslice_fn_for_dispatch = None )

Parametreler

  • data_loader (torch.utils.data.DataLoader) — hazırlamak için standart bir PyTorch DataLoader
  • device_placement (bool, isteğe bağlı) — Hazırlanmış veri yükleyicide (dataloader) partilerin doğru cihaza yerleştirilip yerleştirilmeyeceğini belirtir. Varsayılan olarak self.device_placement değerini kullanır.
  • slice_fn_for_dispatch (Callable, optional) -- If passed, this function will be used to slice tensors across num_processes. Will default to [slice_tensors()](/docs/accelerate/v1.16.0/en/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only when dispatch_batchesis set toTrue` and will be ignored otherwise.

Herhangi bir dağıtık kurulumda eğitim için bir PyTorch DataLoader hazırlar. Bunun yerine Accelerator.prepare() kullanılması önerilir.

Örnek:

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> data_loader = torch.utils.data.DataLoader(...)
>>> data_loader = accelerator.prepare_data_loader(data_loader, device_placement=True)

prepare_model

< >

( model: torch.nn.Moduledevice_placement: bool | None = Noneevaluation_mode: bool = False )

Parametreler

  • model (torch.nn.Module) — Hazırlanacak bir PyTorch modeli. Model yalnızca herhangi bir karma hassasiyet türü olmadan çıkarım için kullanılıyorsa hazırlamanıza gerek yoktur.
  • device_placement (bool, isteğe bağlı) — Modelin uygun cihaza yerleştirilip yerleştirilmeyeceğini belirtir. Varsayılan olarak self.device_placement değerini kullanır.
  • evaluation_mode (bool, isteğe bağlı, varsayılan False) — Modelin yalnızca değerlendirme için ayarlanıp ayarlanmayacağını belirler; bu işlem, karma hassasiyeti uygulayarak ve torch.compile (eğer Accelerator nesnesinde yapılandırılmışsa) çağrılarak gerçekleştirilir.

Herhangi bir dağıtık kurulumda bir PyTorch modelini eğitim için hazırlar. Bunun yerine Accelerator.prepare() kullanılması önerilir.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume a model is defined
>>> model = accelerator.prepare_model(model)

prepare_optimizer

< >

( optimizer: torch.optim.Optimizerdevice_placement = None )

Parametreler

  • optimizer (torch.optim.Optimizer) — Hazırlanacak düz bir PyTorch optimizatörü
  • device_placement (bool, isteğe bağlı) — Optimizatörün doğru cihaza yerleştirilip yerleştirilmeyeceğini belirtir. Varsayılan olarak self.device_placement değerini kullanır.

Herhangi bir dağıtık kurulumda eğitim için bir PyTorch Optimizer hazırlar. Bunun yerine Accelerator.prepare() kullanılması önerilir.

Örnek:

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> optimizer = torch.optim.Adam(...)
>>> optimizer = accelerator.prepare_optimizer(optimizer, device_placement=True)

prepare_scheduler

< >

( scheduler: LRScheduler )

Parametreler

  • scheduler (torch.optim.lr_scheduler.LRScheduler) — hazırlamak için standart bir PyTorch zamanlayıcısı

Herhangi bir dağıtık kurulumda eğitim için bir PyTorch Scheduler hazırlar. Bunun yerine Accelerator.prepare() kullanılması önerilir.

Örnek:

>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> optimizer = torch.optim.Adam(...)
>>> scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, ...)
>>> scheduler = accelerator.prepare_scheduler(scheduler)

print

< >

( *args**kwargs )

Sunucu başına yalnızca bir kez yazdırmak için print() işlevinin doğrudan ikamesi.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> accelerator.print("Hello world!")

profil

< >

( profile_handler: ProfileKwargs | None = None )

Parametreler

  • profile_handler (ProfileKwargs, isteğe bağlı) — Bu context manager için kullanılacak profil işleyicisi. Geçirilmezse, Accelerator nesnesinde ayarlanan işleyici kullanılır.

Bağlam yöneticisinin içindeki kodu profilleyecektir. profile_handler.output_trace_dir ayarlıysa profil, bir Chrome Trace dosyasına kaydedilir.

Accelerator nesnesinde ayarlanan değeri geçersiz kılmak için farklı bir profile_handler geçirilebilir.

Örnek:

# Profile with default settings
from accelerate import Accelerator
from accelerate.utils import ProfileKwargs

accelerator = Accelerator()
with accelerator.profile() as prof:
    train()
accelerator.print(prof.key_averages().table())


# Profile with the custom handler
def custom_handler(prof):
    print(prof.key_averages().table(sort_by="self_cpu_time_total", row_limit=10))


kwargs = ProfileKwargs(schedule_option=dict(wait=1, warmup=1, active=1), on_trace_ready=custom_handler)
accelerator = Accelerator(kwarg_handler=[kwargs])
with accelerator.profile() as prof:
    for _ in range(10):
        train_iteration()
        prof.step()


# Profile and export to Chrome Trace
kwargs = ProfileKwargs(output_trace_dir="output_trace")
accelerator = Accelerator(kwarg_handler=[kwargs])
with accelerator.profile():
    train()

reduce

< >

( tensorreduction = 'sum'scale = 1.0 ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor

Parametreler

  • tensor (torch.Tensor veya torch.Tensor içeren iç içe geçmiş bir tuple/list/dictionary) — Tüm süreçler arasında indirgenmesi gereken tensörler.
  • reduction (str, isteğe bağlı, varsayılan “sum”) — Bir indirgeme türü; ‘sum’, ‘mean’, ‘max’ veya ‘none’ değerlerinden biri olabilir. ‘none’ değeri verilirse hiçbir işlem yapılmaz.
  • scale (float, isteğe bağlı, varsayılan 1.0) — reduce işleminden sonra uygulanacak varsayılan ölçekleme değeri, yalnızca XLA üzerinde geçerlidir.

Dönüş değeri

torch.Tensor veya torch.Tensor içeren iç içe geçmiş bir tuple/list/dictionary

Azaltılmış tensör(ler).

reduction değerine göre tensor içindeki değerleri tüm süreçler arasında azaltın.

Not: Tüm süreçler azaltılmış değeri alır.

Örnek:

>>> # Assuming two processes
>>> import torch
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> process_tensor = torch.arange(accelerator.num_processes) + 1 + (2 * accelerator.process_index)
>>> process_tensor = process_tensor.to(accelerator.device)
>>> reduced_tensor = accelerator.reduce(process_tensor, reduction="sum")
>>> reduced_tensor
tensor([4, 6])

register_for_checkpointing

< >

( *objects )

objects öğelerini not eder ve save_state veya load_state sırasında onları kaydeder ya da yükler.

Bunlar, durumun aynı betik içinde yüklenmesi veya kaydedilmesi sırasında kullanılmalıdır. Farklı betiklerde kullanılmak üzere tasarlanmamıştır.

Her object, saklanabilmesi için bir load_state_dict ve state_dict fonksiyonuna sahip olmalıdır.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume `CustomObject` has a `state_dict` and `load_state_dict` function.
>>> obj = CustomObject()
>>> accelerator.register_for_checkpointing(obj)
>>> accelerator.save_state("checkpoint.pt")

register_load_state_pre_hook

< >

( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle

Parametreler

Dönüş değeri

torch.utils.hooks.RemovableHandle

eklenen kancayı handle.remove() çağrılarak kaldırılabilmesi için kullanılan bir tutamaç

Accelerator.load_state() içinde load_checkpoint çağrılmadan önce çalıştırılacak bir ön kancası (pre hook) kaydeder.

Hook aşağıdaki imzaya sahip olmalıdır:

hook(models: list[torch.nn.Module], input_dir: str) -> None

models argümanı, accelerator._models altında hızlandırıcı durumuna kaydedilen modellerdir ve input_dir argümanı, Accelerator.load_state() fonksiyonuna geçirilen input_dir argümanıdır.

Yalnızca Accelerator.register_save_state_pre_hook() ile birlikte kullanılmalıdır. Model ağırlıklarının yanı sıra yapılandırmaları yüklemek için faydalı olabilir. Ayrıca, model yüklemesini özelleştirilmiş bir yöntemle geçersiz kılmak için de kullanılabilir. Bu durumda, zaten yüklenmiş modellerin modeller listesinden kaldırıldığından emin olun.

register_save_state_pre_hook

< >

( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle

Parametreler

Dönüş değeri

torch.utils.hooks.RemovableHandle

eklenen kancayı handle.remove() çağrılarak kaldırılabilmesi için kullanılan bir tutamaç

Accelerator.save_state() içinde save_checkpoint çağrılmadan önce çalıştırılacak bir ön kancası (pre hook) kaydeder.

Hook aşağıdaki imzaya sahip olmalıdır:

hook(models: list[torch.nn.Module], weights: list[dict[str, torch.Tensor]], input_dir: str) -> None

models argümanı, accelerator._models altında hızlandırıcı durumuna kaydedilen modellerdir, weights argümanı models durum sözlükleridir ve input_dir argümanı, Accelerator.load_state() fonksiyonuna geçirilen input_dir argümanıdır.

Yalnızca Accelerator.register_load_state_pre_hook() ile birlikte kullanılmalıdır. Model ağırlıklarının yanı sıra yapılandırmaları kaydetmek için faydalı olabilir. Ayrıca, model kaydetme işlemini özelleştirilmiş bir yöntemle geçersiz kılmak için de kullanılabilir. Bu durumda, ağırlıklar listesinden zaten yüklenmiş ağırlıkları kaldırdığınızdan emin olun.

kaydet

< >

( objfsafe_serialization = False )

Parametreler

  • obj (object) — Kaydedilecek nesne.
  • f (str veya os.PathLike) — obj içeriğinin kaydedileceği yer.
  • safe_serialization (bool, isteğe bağlı, varsayılan False) — obj'nin safetensors kullanılarak kaydedilip kaydedilmeyeceği

torch.save yerine kullanın. Nesneyi makine başına bir kez diske kaydedin.

Not: save_on_each_node, bir ProjectConfiguration olarak geçirildiyse, nesne yalnızca ana düğümde bir kez değil, her düğümde bir kez kaydedilir.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> arr = [0, 1, 2, 3]
>>> accelerator.save(arr, "array.pkl")

save_model

< >

( model: torch.nn.Modulesave_directory: Union[str, os.PathLike]max_shard_size: Union[int, str] = '10GB'safe_serialization: bool = True )

Parametreler

  • model — (torch.nn.Module): Kaydedilecek model. Model sarılı veya sarılmamış olabilir.
  • save_directory (str veya os.PathLike) — Kaydedilecek dizin. Var değilse oluşturulur.
  • max_shard_size (int veya str, isteğe bağlı, varsayılan olarak "10GB") — Bir checkpoint'in parçalanmadan önceki maksimum boyutu. Parçalanan checkpoint'lerin her biri bu boyuttan küçük olacaktır. Dize olarak ifade ediliyorsa, birimden (örneğin "5MB").

    Modelin tek bir ağırlığı max_shard_size değerinden büyükse, kendi checkpoint diliminde yer alır ve bu dilim max_shard_size değerinden büyük olur.

  • safe_serialization (bool, isteğe bağlı, varsayılan True) — Modelin safetensors ile mi yoksa geleneksel PyTorch yöntemiyle (bu yöntem pickle kullanır) mı kaydedileceğini belirtir.

Modeli, load_checkpoint_in_model kullanılarak yeniden yüklenebilecek şekilde kaydedin

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model = ...
>>> accelerator.save_model(model, save_directory)

save_state

< >

( output_dir: str | None = Nonesafe_serialization: bool = True**save_model_func_kwargs )

Parametreler

  • output_dir (str veya os.PathLike) — Tüm ilgili ağırlıkların ve durumların kaydedileceği klasörün adı.
  • safe_serialization (bool, isteğe bağlı, varsayılan True) — Modelin safetensors ile mi yoksa geleneksel PyTorch yöntemiyle (bu yöntem pickle kullanır) mı kaydedileceğini belirtir.
  • save_model_func_kwargs (dict, isteğe bağlı) — Altta yatan kaydetme işlevine, örneğin DeepSpeed'in save_checkpoint işlevindeki isteğe bağlı argümanlar gibi, aktarılabilecek model kaydetme için ek anahtar kelime argümanları.

Modelin, optimizasyoncunun, ölçeklendiricinin, RNG üreteçlerinin ve kayıtlı nesnelerin mevcut durumlarını bir klasöre kaydeder.

ProjectConfiguration, automatic_checkpoint_naming etkinleştirilerek Accelerator nesnesine geçirildiyse, kontrol noktaları self.project_dir/checkpoints dizinine kaydedilir. Mevcut kayıtların sayısı total_limit değerinden büyükse, en eski kayıt silinir. Her kontrol noktası, checkpoint_<iteration> adlı ayrı klasörlerde saklanır.

Aksi takdirde yalnızca output_dir dizinine kaydedilirler.

Sadece eğitim sırasında bir kontrol noktası kaydetmek ve durumu aynı ortamda geri yüklemek istendiğinde kullanılmalıdır.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer, lr_scheduler = ...
>>> model, optimizer, lr_scheduler = accelerator.prepare(model, optimizer, lr_scheduler)
>>> accelerator.save_state(output_dir="my_checkpoint")

set_trigger

< >

( )

İç tetikleyici tensörünü mevcut işlemde 1 olarak ayarlar. Ardından, tüm işlemler arasında kontrol yapacak bir sonraki kontrolün bu işlevi kullanması gerekir.

Not: wait_for_everyone() gerektirmez

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> # Assume later in the training script
>>> # `should_do_breakpoint` is a custom function to monitor when to break,
>>> # e.g. when the loss is NaN
>>> if should_do_breakpoint(loss):
...     accelerator.set_trigger()
>>> # Assume later in the training script
>>> if accelerator.check_breakpoint():
...     break

skip_first_batches

< >

( dataloadernum_batches: int = 0 )

Parametreler

  • dataloader (torch.utils.data.DataLoader) — Atlanacak partilerin yer aldığı veri yükleyici.
  • num_batches (int, isteğe bağlı, varsayılan 0) — Atlanacak parti sayısı

İlk num_batches öğesini verimli bir şekilde atlayacak yeni bir torch.utils.data.DataLoader oluşturur.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> dataloader, model, optimizer, scheduler = accelerator.prepare(dataloader, model, optimizer, scheduler)
>>> skipped_dataloader = accelerator.skip_first_batches(dataloader, num_batches=2)
>>> # for the first epoch only
>>> for input, target in skipped_dataloader:
...     optimizer.zero_grad()
...     output = model(input)
...     loss = loss_func(output, target)
...     accelerator.backward(loss)
...     optimizer.step()

>>> # subsequent epochs
>>> for input, target in dataloader:
...     optimizer.zero_grad()
...     ...

split_between_processes

< >

( inputs: list | tuple | dict | torch.Tensorapply_padding: bool = False )

Parametreler

  • inputs (list, tuple, torch.Tensor veya list/tuple/torch.Tensor içeren dict) — Süreçler arasında bölünecek girdi.
  • apply_padding (bool, optional, varsayılan False) — Girdinin son elemanını tekrarlayarak tüm süreçlerin aynı sayıda elemana sahip olmasını sağlamak için dolgu uygulanıp uygulanmayacağı. Çıktılarda Accelerator.gather() gibi işlemler yapmaya çalışırken veya süreç sayısından daha az girdi geçirirken faydalıdır. Bu durumda, daha sonra dolgulu elemanları düşürmeyi unutmayın.

input değerini self.num_processes arasında hızlı bir şekilde dağıtır ve ardından ilgili işlemde kullanılabilir. Farklı istemler gibi dağıtık çıkarım senaryolarında faydalıdır.

Bir dict kullanırken tüm anahtarların aynı sayıda öğeye sahip olması gerektiğini unutmayın.

Örnek:

# Assume there are two processes
from accelerate import Accelerator

accelerator = Accelerator()
with accelerator.split_between_processes(["A", "B", "C"]) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C"]

with accelerator.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C", "C"]

trigger_sync_in_backward

< >

( model )

Parametreler

  • model (torch.nn.Module) — Gradyan senkronizasyonunun tetikleneceği model.

Accelerator.no_sync altında birden fazla ileri geçişten sonra, modelin bir sonraki geriye doğru geçişinde gradyanların senkronizasyonunu tetikleyin (yalnızca çoklu GPU senaryolarında geçerlidir).

Betik dağıtık modda başlatılmadıysa, bu bağlam yöneticisi hiçbir şey yapmaz.

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> dataloader, model, optimizer = accelerator.prepare(dataloader, model, optimizer)

>>> with accelerator.no_sync():
...     loss_a = loss_func(model(input_a))  # first forward pass
...     loss_b = loss_func(model(input_b))  # second forward pass
>>> accelerator.backward(loss_a)  # No synchronization across processes, only accumulate gradients
>>> with accelerator.trigger_sync_in_backward(model):
...     accelerator.backward(loss_b)  # Synchronization across all processes
>>> optimizer.step()
>>> optimizer.zero_grad()

unscale_gradients

< >

( optimizer = None )

Parametreler

  • optimizer (torch.optim.Optimizer veya list[torch.optim.Optimizer], isteğe bağlı) — Gradyanların ölçeklenmemesi (unscale) gereken optimizör(ler). Ayarlanmazsa, prepare() fonksiyonuna geçirilen tüm optimizörlerdeki gradyanların ölçeklenmemesi sağlanır.

AMP ile karma hassasiyetli eğitimde gradyanları ölçek dışı bırakın. Diğer tüm ayarlarda bu bir noop'tur.

Muhtemelen Accelerator.clipgrad_norm() veya Accelerator.clipgrad_value() üzerinden çağrılmalıdır

Örnek:

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model, optimizer = accelerator.prepare(model, optimizer)
>>> outputs = model(inputs)
>>> loss = loss_fn(outputs, labels)
>>> accelerator.backward(loss)
>>> accelerator.unscale_gradients(optimizer=optimizer)

unwrap_model

< >

( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = True ) → torch.nn.Module

Parametreler

  • model (torch.nn.Module) — Sarmalması kaldırılacak model.
  • keep_fp32_wrapper (bool, isteğe bağlı, varsayılan True) — Eklenmişse karma hassasiyet kancasının kaldırılmaması gerekip gerekmediğini belirtir.
  • keep_torch_compile (bool, isteğe bağlı, varsayılan True) — Derlenmişse, derlenmiş modelin sarmalayıcısının kaldırılmaması gerekip gerekmediğini belirtir.

Dönüş değeri

torch.nn.Module

Sarmalanan model.

model nesnesini, prepare() tarafından eklenmiş olabilecek ek katmandan ayıklar. Modelin kaydedilmesinden önce kullanışlıdır.

Örnek:

>>> # Assuming two GPU processes
>>> from torch.nn.parallel import DistributedDataParallel
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> model = accelerator.prepare(MyModel())
>>> print(model.__class__.__name__)
DistributedDataParallel

>>> model = accelerator.unwrap_model(model)
>>> print(model.__class__.__name__)
MyModel

verify_device_map

< >

( model: torch.nn.Module )

model'in auto'a benzeyen bir device-map ile büyük model çıkarımı için hazırlanmadığını doğrular.

wait_for_everyone

< >

( )

Mevcut sürecin çalışmasını, diğer tüm süreçler o noktaya ulaşana kadar durdurur (bu nedenle betik yalnızca tek bir süreçte çalıştırıldığında hiçbir işe yaramaz). Bir model kaydetmeden önce yapmak için faydalıdır.

Örnek:

>>> # Assuming two GPU processes
>>> import time
>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> if accelerator.is_main_process:
...     time.sleep(2)
>>> else:
...     print("I'm waiting for the main process to finish its sleep...")
>>> accelerator.wait_for_everyone()
>>> # Should print on every process at the same time
>>> print("Everyone is here")

Yardımcılar

accelerate.utils.gather_object

< >

( object: Any )

Parametreler

  • object (iç içe list/tuple/dictionary of picklable object) — Toplanacak veri.

Tüm cihazlardan, nesnelerin iç içe geçmiş bir liste/tuple/sözlüğündeki nesneyi özyinelemeli olarak toplayın.

Update on GitHub