Accelerate documentation
Hızlandırıcı
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
< source >( 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ılanTrue) — 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şkenindekiACCELERATE_MIXED_PRECISIONdeğerini kullanır; bu da mevcut sistemin accelerate yapılandırmasındaki varsayılan değeri veyaaccelerate.launchkomutuyla 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.accumulateile birlikte kullanılmalıdır. Verilmezse,ACCELERATE_GRADIENT_ACCUMULATION_STEPSortam değişkenindeki değere varsayılan olarak ayarlanır. Ayrıca birGradientAccumulationPluginü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ğı.Trueolarak 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 onlaraaccelerator.state.get_deepspeed_plugin(key)üzerinden erişin.deepspeed_pluginsiç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 yerineparallelism_configiletp_sizekullanı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
strveya 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çinGeneralTrackeruygulamaları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ılanTrue) — Öğrenme hızı zamanlayıcısı, optimizörle aynı anda adım atıyorsaTrue, yalnızca belirli koşullar altında (örneğin her dönemin sonunda) yapılıyorsaFalseolarak 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 (
strveya 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
backendveyamodeayarlaması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_stepsile 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
< source >( *models )
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()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.
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.
İç 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():
... breakAccelerate.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.
clip_grad_norm_
< source >( 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()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()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)
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.
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.
topla
< source >( tensor ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Parametreler
- tensor (
torch.Tensorveyatorch.Tensoriç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
< source >( input_datause_gather_object = False )
Parametreler
- input_data (
torch.Tensor,object,torch.Tensoriçeren iç içe geçmiş bir tuple/list/dictionary veyaobjectiç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)
9get_state_dict
< source >( modelunwrap = True ) → dict
Parametreler
- model (
torch.nn.Module) — Accelerator.prepare() üzerinden gönderilen bir PyTorch modeli - unwrap (
bool, isteğe bağlı, varsayılanTrue) —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.
get_tracker
< source >( name: strunwrap: bool = False ) → GeneralTracker
Yalnızca ana işlemde, name değerine göre self.trackers içinden bir tracker döndürür.
join_uneven_inputs
< source >( joinableseven_batches = None )
Parametreler
- joinables (
list[torch.distributed.algorithms.Joinable]) —torch.distributed.algorithms.Joinablealt sınıfı olan modellerin veya optimizörlerin listesi. En yaygın olarak, DistributedDataParallel eğitimi içinAccelerator.prepareile hazırlanmış bir PyTorch Module'dir. - even_batches (
bool, isteğe bağlı) — Ayarlanırsa,Acceleratoriçinde ayarlananeven_batchesdeğerinin üzerine yazar. Sağlanmazsa, varsayılanAcceleratordeğ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_inputsyalnı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
< source >( input_dir: str | None = Noneload_kwargs: dict | None = None**load_model_func_kwargs )
Parametreler
- input_dir (
strveyaos.PathLike) — Tüm ilgili ağırlıkların ve durumların kaydedildiği klasörün adı.automatic_checkpoint_namingkullanılıyorsaNoneolabilir 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, alttakiloadfonksiyonu 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'inload_checkpointişlevi için isteğe bağlı argümanlar veya modelin ve optimizasyonun yükleneceğimap_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.
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 optimizörlerinde geriye yayılımı çalıştırır.
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
< source >( 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çinno_restore_bufferskullanabilirsiniz. - buffer_seq_dims (
list[int],optional) —buffersdizilerinin boyutları. - no_restore_buffers (
set[torch.Tensor],optional) — Bu küme,buffers'un bir alt kümesi olmalıdır. Bağlam çıkışından sonrabuffersargü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 veparallelism_config.cp_size>
- 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.
no_sync
< source >( model )
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
< source >( function: Callable[..., Any] )
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.
on_local_main_process
< source >( function: Callable[..., Any] | None = None )
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
< source >( function: Callable[..., Any] | None = Nonelocal_process_index: int | None = None )
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
< source >( function: Callable[..., Any] | None = None )
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.
on_process
< source >( function: Callable[..., Any] | None = Noneprocess_index: int | None = None )
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.
pad_across_processes
< source >( 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ılanFalse) — 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
< source >( *argsdevice_placement = None )
Parametreler
- *args (liste of objects) —
Aşağıdaki nesne türlerinden herhangi biri:
torch.utils.data.DataLoader: PyTorch veri yükleyicisitorch.nn.Module: PyTorch Modülütorch.optim.Optimizer: PyTorch Optimizertorch.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.argsile 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
< source >( 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 olarakself.device_placementdeğerini kullanır. - slice_fn_for_dispatch (
Callable, optional) -- If passed, this function will be used to slice tensors acrossnum_processes. Will default to [slice_tensors()](/docs/accelerate/v1.16.0/en/package_reference/utilities#accelerate.utils.slice_tensors). This argument is used only whendispatch_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.
prepare_model
< source >( 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 olarakself.device_placementdeğerini kullanır. - evaluation_mode (
bool, isteğe bağlı, varsayılanFalse) — Modelin yalnızca değerlendirme için ayarlanıp ayarlanmayacağını belirler; bu işlem, karma hassasiyeti uygulayarak vetorch.compile(eğerAcceleratornesnesinde 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.
prepare_optimizer
< source >( optimizer: torch.optim.Optimizerdevice_placement = None )
Herhangi bir dağıtık kurulumda eğitim için bir PyTorch Optimizer hazırlar. Bunun yerine Accelerator.prepare() kullanılması önerilir.
prepare_scheduler
< source >( scheduler: LRScheduler )
Herhangi bir dağıtık kurulumda eğitim için bir PyTorch Scheduler hazırlar. Bunun yerine Accelerator.prepare() kullanılması önerilir.
Sunucu başına yalnızca bir kez yazdırmak için print() işlevinin doğrudan ikamesi.
profil
< source >( profile_handler: ProfileKwargs | None = None )
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
< source >( tensorreduction = 'sum'scale = 1.0 ) → torch.Tensor, or a nested tuple/list/dictionary of torch.Tensor
Parametreler
- tensor (
torch.Tensorveyatorch.Tensoriç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])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 birload_state_dictvestate_dictfonksiyonuna sahip olmalıdır.
register_load_state_pre_hook
< source >( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle
Parametreler
- hook (
Callable) —load_checkpointçağrılmadan önce Accelerator.load_state() içinde çağrılacak bir işlev.
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
< source >( hook: Callable[..., None] ) → torch.utils.hooks.RemovableHandle
Parametreler
- hook (
Callable) —save_checkpointçağrılmadan önce Accelerator.save_state() içinde çağrılacak bir işlev.
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
< source >( objfsafe_serialization = False )
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.
save_model
< source >( 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 (
strveyaos.PathLike) — Kaydedilecek dizin. Var değilse oluşturulur. - max_shard_size (
intveyastr, 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_sizedeğerinden büyükse, kendi checkpoint diliminde yer alır ve bu dilimmax_shard_sizedeğerinden büyük olur. - safe_serialization (
bool, isteğe bağlı, varsayılanTrue) — Modelinsafetensorsile mi yoksa geleneksel PyTorch yöntemiyle (bu yöntempicklekullanır) mı kaydedileceğini belirtir.
Modeli, load_checkpoint_in_model kullanılarak yeniden yüklenebilecek şekilde kaydedin
save_state
< source >( output_dir: str | None = Nonesafe_serialization: bool = True**save_model_func_kwargs )
Parametreler
- output_dir (
strveyaos.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ılanTrue) — Modelinsafetensorsile mi yoksa geleneksel PyTorch yöntemiyle (bu yöntempicklekullanır) mı kaydedileceğini belirtir. - save_model_func_kwargs (
dict, isteğe bağlı) — Altta yatan kaydetme işlevine, örneğin DeepSpeed'insave_checkpointiş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.
İç 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():
... breakskip_first_batches
< source >( dataloadernum_batches: int = 0 )
İ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
< source >( inputs: list | tuple | dict | torch.Tensorapply_padding: bool = False )
Parametreler
- inputs (
list,tuple,torch.Tensorveyalist/tuple/torch.Tensoriçerendict) — Süreçler arasında bölünecek girdi. - apply_padding (
bool,optional, varsayılanFalse) — 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ılardaAccelerator.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
< source >( 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
< source >( optimizer = None )
Parametreler
- optimizer (
torch.optim.Optimizerveyalist[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
unwrap_model
< source >( 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ılanTrue) — Eklenmişse karma hassasiyet kancasının kaldırılmaması gerekip gerekmediğini belirtir. - keep_torch_compile (
bool, isteğe bağlı, varsayılanTrue) — 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__)
MyModelmodel'in auto'a benzeyen bir device-map ile büyük model çıkarımı için hazırlanmadığını doğrular.
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
< source >( object: Any )
Tüm cihazlardan, nesnelerin iç içe geçmiş bir liste/tuple/sözlüğündeki nesneyi özyinelemeli olarak toplayın.