Accelerate documentation
Fungsi dan kelas utilitas
Fungsi dan kelas utilitas
Berikut adalah berbagai fungsi utilitas yang disediakan oleh π€ Accelerate, dikelompokkan berdasarkan kasus penggunaan.
Konstanta
Konstanta yang digunakan di seluruh π€ Accelerate sebagai referensi
Berikut adalah konstanta yang digunakan saat memanfaatkan Accelerator.save_state()
utils.MODEL_NAME: "pytorch_model" utils.OPTIMIZER_NAME: "optimizer" utils.RNG_STATE_NAME: "random_states" utils.SCALER_NAME: "scaler.pt utils.SCHEDULER_NAME: "scheduler
Berikut adalah konstanta yang digunakan saat memanfaatkan Accelerator.save_model()
utils.WEIGHTS_NAME: "pytorch_model.bin" utils.SAFE_WEIGHTS_NAME: "model.safetensors" utils.WEIGHTS_INDEX_NAME: "pytorch_model.bin.index.json" utils.SAFE_WEIGHTS_INDEX_NAME: "model.safetensors.index.json"
Kelas Data
Ini adalah dataclass dasar yang digunakan di seluruh π€ Accelerate dan dapat diteruskan sebagai parameter.
Standalone
Ini adalah dataclass mandiri yang digunakan untuk pemeriksaan, seperti jenis sistem distribusi yang digunakan
Mewakili tipe dari lingkungan komputasi.
Nilai:
- LOCAL_MACHINE β perangkat keras klaster privat/kustom.
- AMAZON_SAGEMAKER β Amazon SageMaker sebagai lingkungan komputasi.
Mewakili jenis lingkungan terdistribusi.
Nilai:
- TIDAK β Bukan lingkungan terdistribusi, hanya satu proses.
- MULTI_CPU β Terdistribusi di beberapa node CPU.
- MULTI_GPU β Terdistribusi di beberapa GPU.
- MULTI_MLU β Terdistribusi di beberapa MLU.
- MULTI_SDAA β Terdistribusi di beberapa SDAA.
- MULTI_MUSA β Terdistribusi di beberapa MUSA.
- MULTI_NPU β Terdistribusi di beberapa NPU.
- MULTI_XPU β Terdistribusi di beberapa XPU.
- MULTI_HPU β Terdistribusi di beberapa HPU.
- MULTI_NEURON β Terdistribusi di beberapa core Neuron.
- DEEPSPEED β Menggunakan DeepSpeed.
- FSDP β Menggunakan Fully Sharded Data Parallelism (FSDP).
- XLA β Menggunakan TorchXLA.
- MEGATRON_LM β Menggunakan Megatron-LM.
Mewakili backend dynamo (lihat https://pytorch.org/docs/stable/torch.compiler.html).
Nilai:
- TIDAK β Jangan gunakan torch dynamo.
- EAGER β Menggunakan PyTorch untuk menjalankan GraphModule yang diekstrak. Ini sangat berguna dalam debugging masalah TorchDynamo.
- AOT_EAGER β Menggunakan AotAutograd tanpa compiler, yaitu hanya menggunakan PyTorch eager untuk graf forward dan backward yang diekstrak oleh AotAutograd. Ini berguna untuk debugging, dan kecil kemungkinannya memberikan peningkatan kecepatan.
- INDUCTOR β Menggunakan backend TorchInductor dengan AotAutograd dan cudagraphs dengan memanfaatkan kernel Triton yang dibuat kode. Baca lebih lanjut
- AOT_TS_NVFUSER β nvFuser dengan AotAutograd/TorchScript. Baca lebih lanjut
- NVPRIMS_NVFUSER β nvFuser dengan PrimTorch. Baca lebih lanjut
- CUDAGRAPHS β cudagraphs dengan AotAutograd. Baca selengkapnya
- OFI β Menggunakan Torchscript optimize_for_inference. Hanya untuk inferensi. Baca lebih lanjut
- FX2TRT β Menggunakan Nvidia TensorRT untuk optimasi inferensi. Hanya untuk inferensi. Baca lebih lanjut
- ONNXRT β Menggunakan ONNXRT untuk inferensi pada CPU/GPU. Hanya inferensi. Baca selengkapnya
- TENSORRT β Menggunakan ONNXRT untuk menjalankan TensorRT guna optimasi inferensi. Baca lebih lanjut
- AOT_TORCHXLA_TRACE_ONCE β Menggunakan Pytorch/XLA dengan optimasi TorchDynamo, untuk pelatihan. Baca lebih lanjut
- TORCHXLA_TRACE_ONCE β Menggunakan Pytorch/XLA dengan optimasi TorchDynamo, untuk inferensi. Baca lebih lanjut
- TVM β Menggunakan Apache TVM untuk optimasi inferensi. Baca selengkapnya
- HPU_BACKEND β Menggunakan backend HPU untuk optimasi inferensi.
- NEURON β Menggunakan backend AWS Neuron untuk Trainium/Inferentia.
Mewakili jenis pelacak eksperimen yang didukung
Nilai:
- SEMUA β semua pelacak yang tersedia di lingkungan yang didukung
- TENSORBOARD β TensorBoard sebagai pelacak eksperimen
- WANDB β wandb sebagai pelacak eksperimen
- TRACKIO β trackio sebagai pelacak eksperimen
- COMETML β comet_ml sebagai pelacak eksperimen
- MLFLOW β mlflow sebagai pelacak eksperimen
- CLEARML β clearml sebagai pelacak eksperimen
- DVCLIVE β dvclive sebagai pelacak eksperimen
- SWANLAB β swanlab sebagai pelacak eksperimen
Mewakili jenis presisi yang digunakan pada nilai floating point
Nilai:
- TIDAK β menggunakan presisi penuh (FP32)
- FP16 β menggunakan presisi setengah
- BF16 β menggunakan presisi brain floating point
Mewakili jenis lingkungan terdistribusi.
Nilai:
- TIDAK β Bukan lingkungan terdistribusi, hanya satu proses.
- DATA_PARALLEL β menggunakan sagemaker distributed data parallelism.
- MODEL_PARALLEL β menggunakan sagemaker distributed model parallelism.
Kwargs
Ini adalah argumen yang dapat dikonfigurasi untuk interaksi spesifik di seluruh ekosistem PyTorch yang ditangani oleh Accelerate di balik layar.
kelas accelerate.AutocastKwargs
< source >( enabled: bool = Truecache_enabled: bool | None = None )
Gunakan objek ini di Accelerator Anda untuk menyesuaikan perilaku torch.autocast. Silakan merujuk ke
dokumentasi context manager ini untuk informasi lebih lanjut tentang setiap argumen.
kelas accelerate.DistributedDataParallelKwargs
< source >( dim: int = 0broadcast_buffers: bool = Truebucket_cap_mb: int = 25find_unused_parameters: bool = Falsecheck_reduction: bool = Falsegradient_as_bucket_view: bool = Falsestatic_graph: bool = Falsecomm_hook: DDPCommunicationHookType = <DDPCommunicationHookType.NO: 'no'>comm_wrapper: typing.Literal[<DDPCommunicationHookType.NO: 'no'>, <DDPCommunicationHookType.FP16: 'fp16'>, <DDPCommunicationHookType.BF16: 'bf16'>] = <DDPCommunicationHookType.NO: 'no'>comm_state_option: dict = <factory> )
Gunakan objek ini di Accelerator Anda untuk menyesuaikan cara model Anda dibungkus dalam torch.nn.parallel.DistributedDataParallel. Silakan merujuk ke dokumentasi wrapper ini untuk informasi lebih lanjut tentang setiap argumen.
kelas accelerate.GradScalerKwargs
< source >( init_scale: float = 65536.0growth_factor: float = 2.0backoff_factor: float = 0.5growth_interval: int = 2000enabled: bool = True )
Gunakan objek ini di Accelerator Anda untuk menyesuaikan perilaku presisi campuran, khususnya bagaimana torch.amp.GradScaler atau torch.cuda.amp.GradScaler yang digunakan dibuat. Silakan merujuk ke dokumentasi scaler ini untuk informasi lebih lanjut tentang setiap argumen.
kelas accelerate.InitProcessGroupKwargs
< source >( backend: str | None = 'nccl'init_method: str | None = Nonetimeout: datetime.timedelta | None = None )
Gunakan objek ini di Accelerator Anda untuk menyesuaikan inisialisasi proses terdistribusi. Silakan merujuk ke dokumentasi metode ini untuk informasi lebih lanjut tentang setiap argumen.
Catatan: Jika timeout diatur ke None, nilai default akan didasarkan pada pengaturan backend.
Mixin internal yang mengimplementasikan metode to_kwargs() untuk dataclass.
Mengembalikan kamus yang berisi atribut dengan nilai yang berbeda dari nilai bawaan kelas ini.
Plugin
Ini adalah plugin yang dapat diteruskan ke objek Accelerator. Meskipun didefinisikan di bagian lain dalam dokumentasi, untuk kenyamanan, semuanya tersedia untuk dilihat di sini:
kelas accelerate.DeepSpeedPlugin
< source >( hf_ds_config: Any = Nonegradient_accumulation_steps: int = Nonegradient_clipping: float = Nonezero_stage: int = Noneis_train_batch_min: bool = Trueoffload_optimizer_device: str = Noneoffload_param_device: str = Noneoffload_optimizer_nvme_path: str = Noneoffload_param_nvme_path: str = Nonezero3_init_flag: bool = Nonezero3_save_16bit_model: bool = Nonetransformer_moe_cls_names: str = None )
Parameter
- hf_ds_config (
Any, defaultnyaNone) β Path ke file konfigurasi DeepSpeed atau dict atau objek dari kelasaccelerate.utils.deepspeed.HfDeepSpeedConfig. - gradient_accumulation_steps (
int, defaultnyaNone) β Jumlah langkah untuk mengakumulasi gradien sebelum memperbarui status optimizer. Jika tidak diatur, akan menggunakan nilai langsung dariAccelerator. - gradient_clipping (
float, defaultnyaNone) β Aktifkan pemotongan gradien dengan nilai. - zero_stage (
int, defaultnyaNone) β Pilihan yang tersedia adalah 0, 1, 2, 3. Nilai default akan diambil dari variabel lingkungan. - is_train_batch_min (
bool, defaultnyaTrue) β Jika kedua dataloader train & eval ditentukan, ini akan menentukantrain_batch_size. - offload_optimizer_device (
str, defaultnyaNone) β Pilihan yang tersedia adalah none|cpu|nvme. Hanya berlaku dengan ZeRO Stages 2 dan 3. - offload_param_device (
str, defaultnyaNone) β Pilihan yang tersedia adalah none|cpu|nvme. Hanya berlaku dengan ZeRO Stage 3. - offload_optimizer_nvme_path (
str, defaultnyaNone) β Pilihan yang tersedia adalah /nvme|/local_nvme. Hanya berlaku dengan ZeRO Stage 3. - offload_param_nvme_path (
str, defaultnyaNone) β Pilihan yang tersedia adalah /nvme|/local_nvme. Hanya berlaku dengan ZeRO Stage 3. - zero3_init_flag (
bool, defaultnyaNone) β Flag untuk menunjukkan apakah model 16-bit akan disimpan. Hanya berlaku dengan ZeRO Stage-3. - zero3_save_16bit_model (
bool, defaultnyaNone) β Flag untuk menunjukkan apakah model 16-bit akan disimpan. Hanya berlaku dengan ZeRO Stage-3. - transformer_moe_cls_names (
str, defaultnyaNone) β Daftar nama kelas layer MoE Transformers yang dipisahkan koma (peka huruf besar/kecil). Misalnya,MixtralSparseMoeBlock,Qwen2MoeSparseMoeBlock,JetMoEAttention,JetMoEBlock, dan sebagainya.
Plugin ini digunakan untuk mengintegrasikan DeepSpeed.
deepspeed_config_process
< source >( prefix = ''mismatches = Noneconfig = Nonemust_match = True**kwargs )
Proses konfigurasi DeepSpeed dengan nilai dari kwargs.
Mengatur HfDeepSpeedWeakref untuk menggunakan konfigurasi plugin deepspeed saat ini
kelas accelerate.FullyShardedDataParallelPlugin
< source >( fsdp_version: int = Nonesharding_strategy: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') = Nonereshard_after_forward: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') | bool = Nonebackward_prefetch: str | ForwardRef('torch.distributed.fsdp.BackwardPrefetch') | None = Nonemixed_precision_policy: dict | str | ForwardRef('torch.distributed.fsdp.MixedPrecision') | ForwardRef('torch.distributed.fsdp.MixedPrecisionPolicy') | None = Noneauto_wrap_policy: typing.Callable | typing.Literal['transformer_based_wrap', 'size_based_wrap', 'no_wrap'] | None = Nonecpu_offload: bool | ForwardRef('torch.distributed.fsdp.CPUOffload') | ForwardRef('torch.distributed.fsdp.CPUOffloadPolicy') = Noneignored_modules: collections.abc.Iterable[torch.nn.Module] | str | None = Nonestate_dict_type: str | ForwardRef('torch.distributed.fsdp.StateDictType') = Nonestate_dict_config: ForwardRef('torch.distributed.fsdp.FullStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedStateDictConfig') | None = Noneoptim_state_dict_config: ForwardRef('torch.distributed.fsdp.FullOptimStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedOptimStateDictConfig') | None = Nonelimit_all_gathers: bool = Trueuse_orig_params: bool | None = Noneparam_init_fn: typing.Callable[[torch.nn.Module], NoneType] | None = Nonesync_module_states: bool | None = Noneforward_prefetch: bool = Noneactivation_checkpointing: bool = Noneactivation_checkpointing_offload: bool = Nonecpu_ram_efficient_loading: bool = Nonetransformer_cls_names_to_wrap: list[str] | None = Nonemin_num_params: int | None = None )
Parameter
- fsdp_version (
int, defaultnya1) β Versi FSDP yang akan digunakan. Defaultnya 1. Jika diatur ke 2, launcher mengharapkan konfigurasi dikonversi ke format FSDP2. - sharding_strategy (
Union[str, torch.distributed.fsdp.ShardingStrategy], defaultnya'FULL_SHARD') β Strategi sharding yang akan digunakan. Harus berupastratau instance daritorch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Sudah tidak disarankan, gunakanreshard_after_forwardsebagai gantinya. - reshard_after_forward (
Union[str, torch.distributed.fsdp.ShardingStrategy, bool], defaultnya'FULL_SHARD'untukfsdp_version=1danTrueuntukfsdp_version=2) β Strategi sharding yang akan digunakan. Harus berupa bool jikafsdp_versiondiatur ke 2, selain itu harus berupastratau instance daritorch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. - backward_prefetch (
Union[str, torch.distributed.fsdp.BackwardPrefetch], defaultnya'NO_PREFETCH') β Strategi prefetch backward yang akan digunakan. Harus berupastratau instance daritorch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch. - mixed_precision_policy (
Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], defaultnyaNone) β Konfigurasi untuk mengaktifkan pelatihan presisi campuran dengan FullyShardedDataParallel. Jika Anda melewatkandict, ia harus memiliki kunci berikut:param_dtype,reduce_dtype, danbuffer_dtype, atau bisa berupa instance daritorch.distributed.fsdp.MixedPrecisionPolicyjikafsdp_versiondiatur ke 2. Jika Anda melewatkanstr, ia harus berupa salah satu nilai berikut: fp8, fp16, bf16, fp32, dan digunakan untuk mengaturparam_dtype,reduce_dtype, danbuffer_dtype. - auto_wrap_policy (
Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults toNO_WRAP) -- A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one oftransformer_based_wrap,size_based_wrap, orno_wrap. Seetorch.distributed.fsdp.wrap.size_based_wrap_policy` for a direction on what it should look like. - cpu_offload (
Union[bool, torch.distributed.fsdp.CPUOffload, torch.distributed.fsdp.CPUOffloadPolicy], defaultnyaFalse) β Apakah parameter akan di-offload ke CPU. Harus berupaboolatau instance daritorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadatautorch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicyjikafsdp_versiondiatur ke 2. - ignored_modules (
Optional[Union[Iterable[torch.nn.Module], str]], defaultnyaNone) β Daftar modul yang diabaikan saat membungkus dengan FSDP. Saat meneruskan string, modul akan dicocokkan berdasarkan nama menggunakan regex fullmatch. Jikafsdp_versiondiatur ke 2, modul dikonversi menjadi parameter dan digunakan. - state_dict_type (
Union[str, torch.distributed.fsdp.StateDictType], defaultnya'FULL_STATE_DICT') β Jenis state dict yang akan digunakan. Jika berupa string, nilainya harus salah satu darifull_state_dict,local_state_dict, atausharded_state_dict. - state_dict_config (
Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], defaultnyaNone) β Konfigurasi state dict yang akan digunakan. Ditentukan berdasarkanstate_dict_typejika tidak diberikan. - optim_state_dict_config (
Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], defaultnyaNone) β Konfigurasi optim state dict yang akan digunakan. Ditentukan berdasarkanstate_dict_typejika tidak diberikan. - limit_all_gathers (
bool, defaultnyaTrue) β Apakah FSDP akan secara eksplisit menyinkronkan thread CPU untuk mencegah terlalu banyak all-gathers yang sedang berjalan. Bool ini hanya memengaruhi strategi sharded yang menjadwalkan all-gathers. Mengaktifkan ini dapat membantu mengurangi jumlah retry malloc CUDA. - use_orig_params (
bool, defaultnyaFalse) β Apakah akan menggunakan parameter asli untuk optimizer. - param_init_fn (
Optional[Callable[[torch.nn.Module], None], defaultnyaNone) βCallable[torch.nn.Module] -> Noneyang menentukan bagaimana modul yang saat ini berada di meta device seharusnya diinisialisasi ke perangkat aktual. Hanya berlaku ketikasync_module_statesadalahTrue. Secara default adalahlambdayang memanggilto_emptypada modul. - sync_module_states (
bool, defaultnyaFalse) β Apakah setiap unit FSDP yang dibungkus secara individual harus melakukan broadcast parameter modul dari rank 0 untuk memastikan mereka sama di semua rank setelah inisialisasi. DefaultnyaFalsekecualicpu_ram_efficient_loadingadalahTrue, maka akan dipaksa diaktifkan. - forward_prefetch (
bool, defaultnyaFalse) β Apakah FSDP akan secara eksplisit melakukan prefetch untuk all-gather berikutnya yang akan datang saat dieksekusi dalam forward pass. Hanya gunakan dengan Static graphs. - activation_checkpointing (
bool, defaultnyaFalse) β Teknik untuk mengurangi penggunaan memori dengan membersihkan aktivasi dari lapisan tertentu dan menghitungnya ulang selama backward pass. Secara efektif, ini menukar waktu komputasi tambahan dengan penggunaan memori yang lebih rendah. - cpu_ram_efficient_loading (
bool, defaultnyaNone) β Jika True, hanya proses pertama yang memuat checkpoint model pretrained, sementara semua proses lainnya memiliki bobot kosong. Hanya berlaku untuk Transformers. Saat menggunakan ini,sync_module_statesharusTrue. - transformer_cls_names_to_wrap (
Optional[List[str]], defaultnyaNone) β Daftar nama kelas lapisan transformer yang akan dibungkus. Hanya berlaku ketikaauto_wrap_policyadalahtransformer_based_wrap. - min_num_params (
Optional[int], defaultnyaNone) β Jumlah parameter minimum yang harus dimiliki sebuah modul agar dapat dibungkus. Hanya berlaku ketikaauto_wrap_policyadalahsize_based_wrap.
Plugin ini digunakan untuk mengaktifkan fully sharded data parallelism.
Diberikan model, membuat auto_wrap_policy berdasarkan kebijakan yang diberikan dan apakah kita dapat menggunakan transformer_cls_to_wrap
Menetapkan kebijakan presisi campuran untuk FSDP
Atur konfigurasi state dict berdasarkan StateDictType.
Memvalidasi kebijakan presisi campuran, yang diabstraksikan agar tidak membawa impor jika tidak diperlukan.
kelas accelerate.utils.GradientAccumulationPlugin
< source >( num_steps: int = Noneadjust_scheduler: bool = Truesync_with_dataloader: bool = Truesync_each_batch: bool = False )
Parameter
- num_steps (
int) β Jumlah langkah untuk mengakumulasi gradien. - adjust_scheduler (
bool, opsional, defaultTrue) β Apakah langkah scheduler akan disesuaikan untuk memperhitungkan jumlah langkah yang diakumulasi. HarusTruejika scheduler yang digunakan belum disesuaikan untuk akumulasi gradien. - sync_with_dataloader (
bool, opsional, defaultTrue) β Apakah akan menyinkronkan pengaturan gradien saat berada di akhir dataloader. - sync_each_batch (
bool, opsional) β Apakah akan menyinkronkan pengaturan gradien pada setiap batch data. Mengatur keTruedapat mengurangi kebutuhan memori saat menggunakan akumulasi gradien dengan pelatihan terdistribusi, dengan mengorbankan kecepatan.
Plugin untuk mengatur perilaku akumulasi gradien. Anda hanya dapat meneruskan salah satu dari gradient_accumulation_plugin atau gradient_accumulation_steps ke Accelerator. Meneruskan keduanya akan memicu error.
kelas accelerate.utils.MegatronLMPlugin
< source >( tp_degree: int = Nonepp_degree: int = Noneuse_custom_fsdp: bool = Noneoverlap_cpu_optimizer_d2h_h2d: bool = Noneno_load_optim: bool = Noneeod_mask_loss: bool = Noneno_save_optim: bool = Noneoptimizer_cpu_offload: bool = Noneuse_precision_aware_optimizer: bool = Nonedecoder_last_pipeline_num_layers: int = Nonerecompute_granularity: str = Nonerecompute_method: str = Nonerecompute_num_layers: int = Noneattention_backend: bool = Noneexpert_model_parallel_size: int = Nonecontext_parallel_size: int = Noneattention_dropout: float = Nonehidden_dropout: float = Noneattention_softmax_in_fp32: bool = Noneexpert_tensor_parallel_size: int = Nonecalculate_per_token_loss: bool = Noneuse_rotary_position_embeddings: bool = Nonenum_micro_batches: int = Nonegradient_clipping: float = Nonesequence_parallelism: bool = Nonerecompute_activations: bool = Noneuse_distributed_optimizer: bool = Nonepipeline_model_parallel_split_rank: int = Nonenum_layers_per_virtual_pipeline_stage: int = Noneis_train_batch_min: str = Truetrain_iters: int = Nonetrain_samples: int = Noneweight_decay_incr_style: str = 'constant'start_weight_decay: float = Noneend_weight_decay: float = Nonelr_decay_style: str = 'linear'lr_decay_iters: int = Nonelr_decay_samples: int = Nonelr_warmup_iters: int = Nonelr_warmup_samples: int = Nonelr_warmup_fraction: float = Nonemin_lr: float = 0consumed_samples: list[int] = Noneno_wd_decay_cond: typing.Callable | None = Nonescale_lr_cond: typing.Callable | None = Nonelr_mult: float = 1.0megatron_dataset_flag: bool = Falseseq_length: int = Noneencoder_seq_length: int = Nonedecoder_seq_length: int = Nonetensorboard_dir: str = Noneset_all_logging_options: bool = Falseeval_iters: int = 100eval_interval: int = 1000return_logits: bool = Falsecustom_train_step_class: typing.Any | None = Nonecustom_train_step_kwargs: dict[str, typing.Any] | None = Nonecustom_model_provider_function: typing.Callable | None = Nonecustom_prepare_model_function: typing.Callable | None = Nonecustom_megatron_datasets_provider_function: typing.Callable | None = Nonecustom_get_batch_function: typing.Callable | None = Nonecustom_loss_function: typing.Callable | None = Noneother_megatron_args: dict[str, typing.Any] | None = None )
Parameter
- tp_degree (
int, defaultnyaNone) β Derajat parallelisme tensor. - pp_degree (
int, defaultnyaNone) β Derajat paralelisme pipeline. - num_micro_batches (
int, defaultnyaNone) β Jumlah micro-batch. - gradient_clipping (
float, defaultnyaNone) β Nilai pemotongan gradien berdasarkan L2 Norm global (0 untuk menonaktifkan). - sequence_parallelism (
bool, defaultnyaNone) β Aktifkan paralelisasi urutan. - recompute_activations (
bool, defaultnyaNone) β Aktifkan rekomputasi aktivasi selektif. - use_distributed_optimizer (
bool, defaultnyaNone) β Aktifkan distributed optimizer. - pipeline_model_parallel_split_rank (
int, defaultnyaNone) β Rank tempat encoder dan decoder harus dipisahkan. - num_layers_per_virtual_pipeline_stage (
int, defaultnyaNone) β Jumlah lapisan per tahap pipeline virtual. - is_train_batch_min (
str, defaultnyaTrue) β Jika kedua dataloader tran & eval ditentukan, ini akan menentukanmicro_batch_size. - train_iters (
int, defaultnyaNone) β Total jumlah sampel untuk dilatih di seluruh run pelatihan. Perhatikan bahwa salah satu dari train-iters atau train-samples harus disediakan saat menggunakanMegatronLMDummyScheduler. - train_samples (
int, defaultnyaNone) β Total jumlah sampel untuk dilatih di seluruh run pelatihan. Perhatikan bahwa salah satu dari train-iters atau train-samples harus disediakan saat menggunakanMegatronLMDummyScheduler. - weight_decay_incr_style (
str, defaultnya'constant') β Fungsi inkremen weight decay. choices=[βconstantβ, βlinearβ, βcosineβ]. - start_weight_decay (
float, defaultnyaNone) β Koefisien weight decay awal untuk regularisasi L2. - end_weight_decay (
float, defaultnyaNone) β Koefisien peluruhan bobot akhir untuk regularisasi L2. - lr_decay_style (
str, defaultnya'linear') β Fungsi peluruhan learning rate. choices=[βconstantβ, βlinearβ, βcosineβ]. - lr_decay_iters (
int, defaultnyaNone) β Jumlah iterasi untuk peluruhan laju belajar. Jika None, defaultnya adalahtrain_iters. - lr_decay_samples (
int, defaultnyaNone) β Jumlah sampel untuk peluruhan laju belajar. Jika None, defaultnya adalahtrain_samples. - lr_warmup_iters (
int, defaultnyaNone) β Jumlah iterasi untuk melakukan pemanasan linear pada learning rate. - lr_warmup_samples (
int, defaultnyaNone) β Jumlah sampel untuk melakukan pemanasan linear pada learning rate. - lr_warmup_fraction (
float, defaultnyaNone) β Fraksi dari lr-warmup-(iters/samples) untuk melakukan warmup linear pada learning rate. - min_lr (
float, defaultnya0) β Nilai minimum untuk learning rate. Scheduler memotong nilai di bawah ambang batas ini. - consumed_samples (
List, defaultnyaNone) β Jumlah sampel yang dikonsumsi dalam urutan yang sama dengan dataloaders pada pemanggilanaccelerator.prepare. - no_wd_decay_cond (
Optional, defaultnyaNone) β Kondisi untuk menonaktifkan weight decay. - scale_lr_cond (
Optional, defaultnyaNone) β Kondisi untuk menskalakan learning rate. - lr_mult (
float, defaultnya1.0) β Pengali learning rate. - megatron_dataset_flag (
bool, defaultnyaFalse) β Apakah format dataset mengikuti format Indexed/Cached/MemoryMapped dari Megatron-LM. - seq_length (
int, defaultnyaNone) β Panjang maksimum urutan yang akan diproses. - encoder_seq_length (
int, defaultnyaNone) β Panjang maksimum urutan yang akan diproses oleh encoder. - decoder_seq_length (
int, defaultnyaNone) β Panjang maksimum urutan untuk diproses oleh decoder. - tensorboard_dir (
str, defaultnyaNone) β Path untuk menyimpan log tensorboard. - set_all_logging_options (
bool, defaultnyaFalse) β Apakah akan mengatur semua opsi log. - eval_iters (
int, defaultnya100) β Jumlah iterasi yang dijalankan untuk evaluasi validasi/tes. - eval_interval (
int, defaultnya1000) β Interval antara menjalankan evaluasi pada set validasi. - return_logits (
bool, defaultnyaFalse) β Apakah akan mengembalikan logits dari model. - custom_train_step_class (
Optional, defaultnyaNone) β Kelas langkah pelatihan kustom. - custom_train_step_kwargs (
Optional, defaultnyaNone) β Kwargs langkah pelatihan kustom. - custom_model_provider_function (
Optional, defaultnyaNone) β Fungsi penyedia model kustom. - custom_prepare_model_function (
Optional, defaultnyaNone) β Fungsi prepare model kustom. - custom_megatron_datasets_provider_function (
Optional, defaultnyaNone) β Fungsi penyedia dataset train_valid_test megatron kustom. - custom_get_batch_function (
Optional, defaultnyaNone) β Fungsi get batch kustom. - custom_loss_function (
Optional, defaultnyaNone) β Fungsi loss kustom. - other_megatron_args (
Optional, defaultnyaNone) β Argumen Megatron-LM lainnya. Silakan merujuk ke Megatron-LM.
Plugin untuk Megatron-LM guna memungkinkan paralelisme tensor, pipeline, urutan, dan data. Juga untuk memungkinkan rekomputasi aktivasi selektif dan kernel terpadu yang dioptimalkan.
kelas accelerate.utils.TorchDynamoPlugin
< source >( backend: DynamoBackend = Nonemode: str = Nonefullgraph: bool = Nonedynamic: bool = Noneoptions: Any = Nonedisable: bool = Falseuse_regional_compilation: bool = None )
Parameter
- backend (
DynamoBackend, defaultnyaNone) β Backend Dynamo yang valid. Lihat https://pytorch.org/docs/stable/torch.compiler.html untuk detail lebih lanjut. - mode (
str, defaultnyaNone) β Pilihan yang tersedia adalah βdefaultβ, βreduce-overheadβ, atau βmax-autotuneβ. - fullgraph (
bool, defaultnyaNone) β Apakah model boleh dipecah menjadi beberapa subgraf. - dynamic (
bool, defaultnyaNone) β Apakah akan menggunakan bentuk dinamis untuk pelacakan. - options (
Any, defaultnyaNone) β Kamus opsi untuk diteruskan ke backend. - disable (
bool, defaultnyaFalse) β Mengubah torch.compile() menjadi no-op untuk pengujian - use_regional_compilation (
bool, defaultnyaNone) β Gunakan ini untuk mengurangi waktu kompilasi cold start dari torch.compile() dengan menargetkan blok berulang dari kelas yang sama dan mengompilasinya secara berurutan agar mengenai cache compiler. Sebagai contoh, padaGPT2LMHeadModel, blok/kelas yang berulang adalahGPT2Block, dan dapat diakses sebagaimodel.transformer.h[0]. Sisa model (misalnya model.lm_head) dikompilasi secara terpisah.
Plugin ini digunakan untuk mengompilasi model dengan PyTorch 2.0
Konfigurasi
Ini adalah kelas yang dapat dikonfigurasi dan diteruskan ke integrasi yang sesuai
kelas accelerate.utils.BnbQuantizationConfig
< source >( load_in_8bit: bool = Falsellm_int8_threshold: float = 6.0load_in_4bit: bool = Falsebnb_4bit_quant_type: str = 'fp4'bnb_4bit_use_double_quant: bool = Falsebnb_4bit_compute_dtype: str = 'fp16'torch_dtype: dtype = Noneskip_modules: list[str] = Nonekeep_in_fp32_modules: list[str] = None )
Parameter
- load_in_8bit (
bool, defaultnyaFalse) β Aktifkan kuantisasi 8bit. - llm_int8_threshold (
float, defaultnya6.0) β Nilai ambang batas outliner. Hanya relevan ketikaload_in_8bit=True. - load_in_4bit (
bool, defaultnyaFalse) β Aktifkan kuantisasi 4bit. - bnb_4bit_quant_type (
str, defaultnyafp4) β Menetapkan tipe data kuantisasi pada lapisanbnb.nn.Linear4Bit. Opsinya adalah {βfp4β,βnp4β}. - bnb_4bit_use_double_quant (
bool, defaultnyaFalse) β Aktifkan kuantisasi bersarang di mana konstanta kuantisasi dari kuantisasi pertama dikuantisasi lagi. - bnb_4bit_compute_dtype (
bool, defaultnyafp16) β Ini mengatur tipe komputasi yang mungkin berbeda dari tipe input. Misalnya, input bisa berupa fp32, tetapi komputasi dapat diatur ke bf16 untuk percepatan. Opsinya adalah {βfp32β,βfp16β,βbf16β}. - torch_dtype (
torch.dtype, defaultnyaNone) β Ini mengatur dtype dari lapisan non-kuantisasi yang tersisa. Perpustakaanbitsandbytesmenyarankan untuk mengatur nilainya ketorch.float16untuk model 8 bit dan menggunakan dtype yang sama dengan dtype komputasi untuk model 4 bit. - skip_modules (
List[str], defaultnyaNone) β Daftar eksplisit modul yang tidak akan dikuantisasi. dtype dari modul-modul ini akan menjaditorch_dtype. - keep_in_fp32_modules (
List, defaultnyaNone) β Daftar eksplisit modul yang tidak kami kuantisasi. Kami menjaganya tetap dalamtorch.float32.
Plugin untuk mengaktifkan kuantisasi 4bit dan 8bit BitsAndBytes
kelas accelerate.DataLoaderConfiguration
< source >( split_batches: bool = Falsedispatch_batches: bool = Noneeven_batches: bool = Trueuse_seedable_sampler: bool = Falsedata_seed: int = Nonenon_blocking: bool = Falseuse_stateful_dataloader: bool = False )
Parameter
- split_batches (
bool, defaultnyaFalse) β Apakah accelerator harus membagi batch yang dihasilkan oleh dataloaders di antara perangkat. JikaTrue, ukuran batch aktual yang digunakan akan sama di semua jenis proses terdistribusi, tetapi harus berupa kelipatan bulat darinum_processesyang Anda gunakan. JikaFalse, ukuran batch aktual yang digunakan akan menjadi yang diatur dalam skrip Anda dikalikan dengan jumlah proses. - dispatch_batches (
bool, defaultnyaNone) β Jika diset keTrue, dataloader yang disiapkan oleh Accelerator hanya diiterasi pada proses utama, lalu batch dipecah dan disiarkan ke setiap proses. Akan default keTrueuntukDataLoaderyang dataset dasarnya adalahIterableDataset,Falseselain itu. - even_batches (
bool, defaultnyaTrue) β Jika diset keTrue, dalam kasus di mana ukuran batch total di seluruh proses tidak membagi dataset secara tepat, sampel di awal dataset akan diduplikasi agar batch dapat dibagi secara merata di antara semua worker. - use_seedable_sampler (
bool, defaultFalse) β Apakah akan menggunakan sampler acak yang sepenuhnya dapat di-seed (data_loader.SeedableRandomSampler). Menjamin hasil pelatihan sepenuhnya dapat direproduksi menggunakan teknik sampling yang berbeda. Meskipun hasil antar-seed mungkin berbeda, rata-rata perbedaannya dapat diabaikan ketika menggunakan beberapa seed berbeda untuk perbandingan. Sebaiknya juga dijalankan dengan set_seed() untuk hasil terbaik. - data_seed (
int, defaultnyaNone) β Seed yang akan digunakan untuk generator dasar saat menggunakanuse_seedable_sampler. JikaNone, generator akan menggunakan seed default saat ini dari torch. - non_blocking (
bool, defaultnyaFalse) β Jika diatur keTrue, dataloader yang disiapkan oleh Accelerator akan memanfaatkan transfer host-ke-perangkat non-blocking, memungkinkan overlap yang lebih baik antara komunikasi dataloader dan komputasi. Disarankan agar dataloader yang disiapkan memilikipin_memoryyang diatur keTrueagar berfungsi dengan baik. - use_stateful_dataloader (
bool, defaultnyaFalse) β Jika diset keTrue, dataloader yang disiapkan oleh Accelerator akan didukung oleh torchdata.StatefulDataLoader. Hal ini memerlukan instalasitorchdataversi 0.8.0 atau lebih tinggi yang mendukung StatefulDataLoader.
Konfigurasi untuk item terkait dataloader saat memanggil accelerator.prepare.
kelas accelerate.utils.ProjectConfiguration
< source >( project_dir: str = Nonelogging_dir: str = Noneautomatic_checkpoint_naming: bool = Falsetotal_limit: int = Noneiteration: int = 0save_on_each_node: bool = False )
Parameter
- project_dir (
str, defaultnyaNone) β Path ke direktori untuk menyimpan data. - logging_dir (
str, defaultnyaNone) β Path ke direktori untuk menyimpan log dari logger yang kompatibel secara lokal. Jika None, defaultnya adalahproject_dir. - automatic_checkpoint_naming (
bool, defaultnyaFalse) β Apakah state yang disimpan harus diberi nama secara otomatis dan iteratif. - total_limit (
int, defaultnyaNone) β Jumlah maksimum total state yang disimpan untuk dipertahankan. - iteration (
int, defaultnya0) β Iterasi simpan saat ini. - save_on_each_node (
bool, defaultnyaFalse) β Saat melakukan pelatihan terdistribusi multi-node, apakah model dan checkpoint disimpan di setiap node, atau hanya di node utama.
Konfigurasi untuk objek Accelerator berdasarkan kebutuhan proyek internal.
Mengatur self.project_dir dan self.logging_dir ke nilai yang sesuai.
Variabel Lingkungan
Ini adalah variabel lingkungan yang dapat diaktifkan untuk berbagai kasus penggunaan
ACCELERATE_DEBUG_MODE(str): Apakah akan menjalankan accelerate dalam mode debug. Informasi lebih lanjut tersedia di sini.
Manipulasi dan Operasi Data
Termasuk di dalamnya adalah operasi data yang meniru operasi torch yang sama tetapi dapat digunakan pada proses terdistribusi.
accelerate.utils.broadcast
< source >( tensorfrom_process: int = 0 )
Broadcast tensor secara rekursif dalam list/tuple/dictionary tensor bersarang ke semua perangkat.
accelerate.utils.broadcast_object_list
< source >( object_listfrom_process: int = 0 )
Broadcast daftar objek yang dapat di-pickle dari satu proses ke proses lainnya.
accelerate.utils.concatenate
< source >( datadim = 0 )
Gabungkan secara rekursif tensor dalam daftar/tuple/dictionary bersarang dari daftar tensor dengan bentuk yang sama. Jika hanya ada satu batch data, data tersebut dikembalikan apa adanya.
accelerate.utils.convert_to_fp32
< source >( tensor )
Mengonversi secara rekursif elemen-elemen dalam daftar/tuple/dictionary tensor yang bersarang dari presisi FP16/BF16 ke FP32.
accelerate.utils.gather
< source >( tensor )
Kumpulkan tensor secara rekursif dalam daftar/tuple/dictionary tensor bersarang dari semua perangkat.
accelerate.utils.gather_object
< source >( object: Any )
Kumpulkan objek secara rekursif dalam daftar/tuple/dictionary objek bersarang dari semua perangkat.
accelerate.utils.get_grad_scaler
< source >( distributed_type: DistributedType = None**kwargs )
Helper generik yang akan menginisialisasi implementasi GradScaler yang benar berdasarkan lingkungan dan mengembalikannya.
accelerate.utils.get_mixed_precision_context_manager
< source >( native_amp: bool = Falseautocast_kwargs: AutocastKwargs = None )
Kembalikan context manager untuk autocasting presisi campuran
accelerate.utils.listify
< source >( data )
Mencari tensor secara rekursif dalam list/tuple/dictionary bersarang dan mengonversinya menjadi list angka.
accelerate.utils.pad_across_processes
< source >( tensordim = 0pad_index = 0pad_first = False )
Parameter
- tensor (nested list/tuple/dictionary of
torch.Tensor) β Data yang akan dikumpulkan. - dim (
int, opsional, default 0) β Dimensi yang akan di-pad. - pad_index (
int, opsional, default 0) β Nilai yang digunakan untuk padding. - pad_first (
bool, opsional, defaultFalse) β Apakah akan melakukan padding di awal atau di akhir.
Pad tensor secara rekursif dalam daftar/tupel/dictionary bertingkat dari tensor di semua perangkat hingga ukuran yang sama sehingga dapat dikumpulkan dengan aman.
accelerate.utils.recursively_apply
< source >( funcdata*argstest_type = <function is_torch_tensor at 0x7f7be94c4460>error_on_other_type = False**kwargs )
Parameter
- func (
callable) β Fungsi yang akan diterapkan secara rekursif. - data (nested list/tuple/dictionary of objects accepted by
test_type) β Data yang akan digunakan untuk menerapkanfunc - *args β
Argumen posisional yang akan diteruskan ke
funcsaat diterapkan pada data yang telah diurai. - test_type (
Callable[[Any], bool], opsional, defaultnyais_torch_tensor) β Predikat yang menentukan apakahfuncharus diterapkan pada objek daun tertentu. - error_on_other_type (
bool, opsional, defaultnyaFalse) β Apakah akan mengembalikan error atau tidak jika setelah unpackingdata, kita mendapatkan objek yangtest_typemengembalikanFalse. JikaFalse, fungsi akan membiarkan objek semacam itu tetap tidak berubah. - **kwargs (argumen kata kunci tambahan, opsional) β
Argumen kata kunci yang akan diteruskan ke
funcsaat diterapkan pada data yang telah diurai.
Terapkan fungsi secara rekursif pada struktur data berupa daftar/tuple/dictionary bersarang dari tipe dasar tertentu.
accelerate.utils.reduce
< source >( tensorreduction = 'mean'scale = 1.0 )
Parameter
- tensor (nested list/tuple/dictionary of
torch.Tensor) β Data yang akan direduksi. - reduction (
str, opsional, default"mean") β Metode reduksi. Bisa berupa βmeanβ, βsumβ, βmaxβ, atau βnoneβ - scale (
float, opsional) β Nilai penskalaan default yang diterapkan setelah reduce, hanya valid di XLA.
Kurangi secara rekursif tensor dalam daftar/tuple/dictionary bersarang dari daftar tensor di semua proses dengan rata-rata dari operasi yang diberikan.
accelerate.utils.send_to_device
< source >( tensordevicenon_blocking = Falseskip_keys = None )
Parameter
- tensor (nested list/tuple/dictionary of
torch.Tensor) β Data yang akan dikirim ke perangkat tertentu. - device (
torch.device) β Perangkat untuk mengirim data. - non_blocking (
bool, opsional, defaultFalse) β JikaTrue, transfer ke perangkat dilakukan secara asinkron, yang memungkinkan pergerakan data tumpang tindih dengan komputasi. Hanya efektif jika perangkat mendukungnya (mis. CUDA). - skip_keys (
stratauList[str], opsional) β Kunci atau daftar kunci dalam dictionarytensoryang nilainya tidak boleh dikirim kedeviceyang ditentukan. Entri dengan kunci-kunci ini tetap berada di device aslinya.
Mengirim elemen-elemen dalam list/tuple/dictionary tensor bersarang secara rekursif ke perangkat yang ditentukan.
accelerate.utils.slice_tensors
< source >( datatensor_sliceprocess_index = Nonenum_processes = None )
Mengambil potongan secara rekursif dalam daftar/tuple/dictionary tensor yang bersarang.
Periksa Lingkungan
Fungsionalitas ini memeriksa status lingkungan kerja saat ini, termasuk informasi tentang sistem operasi itu sendiri, apa yang dapat didukungnya, dan apakah dependensi tertentu sudah terinstal.
Memeriksa apakah bf16 didukung, dengan opsi untuk mengabaikan TPU
Memeriksa apakah perangkat MPS tersedia. Versi minimum yang diperlukan adalah 1.12.
Memeriksa apakah torch_npu terinstal dan, jika perlu, apakah ada NPU di lingkungan
accelerate.utils.is_torch_version
< source >( operation: strversion: str )
Membandingkan versi PyTorch saat ini dengan referensi tertentu menggunakan operasi.
Periksa apakah torch_xla tersedia. Untuk melatih tugas pytorch native di lingkungan dengan torch xla yang terinstal, setel USE_TORCH_XLA ke false.
Memeriksa apakah akselerasi XPU tersedia melalui PyTorch standar (>=2.7) dan apakah ada XPU di lingkungan
Manipulasi Lingkungan
Manajer konteks yang akan menambahkan setiap argumen kata kunci yang diteruskan ke os.environ dan menghapusnya saat keluar.
Akan mengonversi nilai dalam kwargs menjadi string dan mengubah semua kunci menjadi huruf kapital.
Manajer konteks yang akan menghapus variabel lingkungan secara sementara.
Saat konteks ini keluar, variabel lingkungan sebelumnya akan kembali.
accelerate.commands.config.default.write_basic_config
< source >( mixed_precision = 'no'save_location: str = '/home/runner/.cache/huggingface/accelerate/default_config.yaml' )
Parameter
- mixed_precision (
str, opsional, default βnoβ) β Mixed Precision yang akan digunakan. Harus salah satu dari βnoβ, βfp16β, atau βbf16β - save_location (
str, opsional, defaultnyadefault_json_config_file) β Lokasi penyimpanan kustom opsional. Seharusnya diteruskan ke--config_filesaat menggunakanaccelerate launch. Lokasi default berada di dalam folder cache huggingface (~/.cache/huggingface) tetapi dapat ditimpa dengan mengatur variabel lingkunganHF_HOME, diikuti olehaccelerate/default_config.yaml.
Membuat dan menyimpan konfigurasi cluster dasar untuk digunakan pada mesin lokal dengan kemungkinan beberapa GPU. Juga akan mengatur CPU jika mesin tersebut hanya memiliki CPU.
Saat mengatur π€ Accelerate untuk pertama kali, alih-alih menjalankan accelerate config, [~utils.write_basic_config] dapat digunakan sebagai alternatif untuk konfigurasi cepat.
Menugaskan proses saat ini ke node NUMA tertentu. Paling efisien secara ideal jika memiliki setidaknya 2 cpu per node.
Hasil ini di-cache di antara pemanggilan. Jika Anda ingin menimpanya, silakan gunakan accelerate.utils.environment.override_numa_afifnity.
accelerate.utils.environment.override_numa_affinity
< source >( local_process_index: intverbose: bool | None = None )
Menimpa afinitas NUMA apa pun yang disetel untuk proses saat ini. Hal ini sangat membebani dan memerlukan perhitungan ulang afinitas yang akan disetel; idealnya, Anda sebaiknya menggunakan utils.environment.set_numa_affinity sebagai gantinya.
Decorator untuk membersihkan variabel lingkungan accelerate yang disetel oleh kelas atau fungsi yang didekorasi.
Dalam beberapa situasi, memanggil kelas atau fungsi tertentu dapat menyebabkan variabel lingkungan accelerate diset dan tidak dibersihkan setelahnya. Sebagai contoh, saat memanggil:
TrainingArguments(fp16=True, β¦)
Variabel lingkungan berikut akan disetel:
ACCELERATE_MIXED_PRECISION=fp16
Hal ini dapat memengaruhi kode berikutnya, karena variabel lingkungan memiliki prioritas lebih tinggi daripada TrainingArguments(fp16=False). Hal ini terutama relevan untuk pengujian unit, di mana kita ingin menghindari agar pengujian individual tidak memiliki efek samping satu sama lain. Hiasi fungsi pengujian unit atau seluruh kelas dengan dekorator ini untuk memastikan bahwa setelah setiap pengujian, variabel lingkungan dibersihkan. Ini berfungsi untuk unittest.TestCase dan kelas normal (pytest); ini juga berfungsi saat menghiasi kelas induk.
Memori
accelerate.find_executable_batch_size
< source >( function: callable | None = Nonestarting_batch_size: int = 128reduce_batch_size_fn: callable | None = None )
Parameter
- function (
callable, opsional) β Fungsi untuk dibungkus - starting_batch_size (
int, opsional) β Ukuran batch yang akan dicoba untuk muat ke dalam memori - reduce_batch_size_fn (
callable, opsional) β Fungsi untuk menentukan ukuran batch baru setelah terjadi error out-of-memory. Jika tidak disediakan, ukuran batch akan dikalikan dengan 0,9 pada setiap kegagalan. Fungsi ini tidak menerima argumen dan harus mengembalikan ukuran batch baru (yang dikurangi) sebagaiint.
Decorator dasar yang akan mencoba mengeksekusi function. Jika gagal karena pengecualian yang terkait dengan out-of-memory atau CUDNN, ukuran batch dikalikan dengan 0,9 dan diteruskan ke function
function harus menerima parameter batch_size sebagai argumen pertamanya.
Modeling
Utilitas ini berkaitan dengan interaksi dengan model PyTorch
Menghitung ukuran total model dan lapisan terbesarnya
accelerate.utils.compute_module_sizes
< source >( model: Moduledtype: str | torch.device | None = Nonespecial_dtypes: dict[str, str | torch.device] | None = Nonebuffers_only: bool = False )
Hitung ukuran setiap submodul dari model tertentu.
accelerate.utils.extract_model_from_parallel
< source >( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = Truerecursive: bool = False ) β torch.nn.Module
Parameter
- model (
torch.nn.Module) β Model yang akan diekstrak. - keep_fp32_wrapper (
bool, opsional) β Apakah akan menghapus hook presisi campuran dari model. - keep_torch_compile (
bool, opsional) β Apakah akan membuka bungkus model yang dikompilasi. - recursive (
bool, opsional, defaultFalse) β Apakah akan mengekstrak secara rekursif semua kasusmodule.moduledarimodelserta membuka bungkus sublayer anak secara rekursif, bukan hanya kontainer terdistribusi tingkat atas.
Mengembalikan
torch.nn.Module
Model yang diekstrak.
Ekstrak model dari kontainer distribusinya.
accelerate.utils.get_balanced_memory
< source >( model: Modulemax_memory: dict[int | str, int | str] | None = Noneno_split_module_classes: list[str] | None = Nonedtype: str | torch.dtype | None = Nonespecial_dtypes: dict[str, str | torch.device] | None = Nonelow_zero: bool = False )
Parameter
- model (
torch.nn.Module) β Model yang akan dianalisis. - max_memory (
Dict, opsional) β Kamus pengidentifikasi perangkat ke memori maksimum. Akan menggunakan memori maksimum yang tersedia jika tidak diatur. Contoh:max_memory={0: "1GB"}. - no_split_module_classes (
List[str], opsional) β Daftar nama kelas layer yang tidak boleh dipecah antar perangkat (misalnya layer apa pun yang memiliki koneksi residual). - dtype (
stratautorch.dtype, opsional) β Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat. - special_dtypes (
Dict[str, Union[str, torch.device]], opsional) β Jika disediakan, dtype khusus yang dipertimbangkan untuk beberapa bobot tertentu (akan menimpa dtype yang digunakan sebagai default untuk semua bobot). - low_zero (
bool, opsional) β Meminimalkan jumlah bobot pada GPU 0, yang berguna ketika GPU tersebut digunakan untuk operasi lain (seperti fungsi generate dari Transformers).
Hitung kamus max_memory untuk infer_auto_device_map() yang akan menyeimbangkan penggunaan setiap GPU yang tersedia.
Semua komputasi dilakukan dengan menganalisis ukuran dan dtype dari parameter model. Akibatnya, model dapat berada pada perangkat meta (seperti yang akan terjadi jika diinisialisasi di dalam context manager
init_empty_weights).
accelerate.utils.get_max_layer_size
< source >( modules: list[tuple[str, torch.nn.Module]]module_sizes: dict[str, int]no_split_module_classes: list[str] ) β Tuple[int, List[str]]
Parameter
- modules (
List[Tuple[str, torch.nn.Module]]) β Daftar modul bernama tempat kita ingin menentukan ukuran lapisan maksimum. - module_sizes (
Dict[str, int]) β Kamus yang memetakan setiap nama layer ke ukurannya (seperti yang dihasilkan olehcompute_module_sizes). - no_split_module_classes (
List[str]) β Daftar nama kelas untuk lapisan yang tidak ingin dipecah.
Mengembalikan
Tuple[int, List[str]]
Ukuran maksimum dari sebuah layer beserta daftar nama layer yang mencapai ukuran maksimum tersebut.
Fungsi utilitas yang akan memindai daftar modul bernama dan mengembalikan ukuran maksimum yang digunakan oleh satu lapisan penuh. Definisi lapisan adalah:
- modul tanpa anak langsung (hanya parameter dan buffer)
- modul yang nama kelasnya ada dalam daftar
no_split_module_classes
accelerate.infer_auto_device_map
< source >( model: Modulemax_memory: dict[int | str, int | str] | None = Noneno_split_module_classes: list[str] | None = Nonedtype: str | torch.dtype | None = Nonespecial_dtypes: dict[str, str | torch.dtype] | None = Noneverbose: bool = Falseclean_result: bool = Trueoffload_buffers: bool = Falsefallback_allocation: bool = False )
Parameter
- model (
torch.nn.Module) β Model yang akan dianalisis. - max_memory (
Dict, opsional) β Kamus pengidentifikasi perangkat ke memori maksimum. Akan menggunakan memori maksimum yang tersedia jika tidak diatur. Contoh:max_memory={0: "1GB"}. - no_split_module_classes (
List[str], opsional) β Daftar nama kelas layer yang tidak boleh dipecah antar perangkat (misalnya layer apa pun yang memiliki koneksi residual). - dtype (
stratautorch.dtype, opsional) β Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat. - special_dtypes (
Dict[str, Union[str, torch.device]], opsional) β Jika disediakan, dtype khusus yang dipertimbangkan untuk beberapa bobot tertentu (akan menimpa dtype yang digunakan sebagai default untuk semua bobot). - verbose (
bool, opsional, defaultFalse) β Apakah akan memberikan pernyataan debugging saat fungsi membangun device_map. - clean_result (
bool, opsional, defaultTrue) β Bersihkan device_map hasil akhir dengan mengelompokkan semua submodul yang berada di perangkat yang sama. - offload_buffers (
bool, opsional, defaultFalse) β Pada lapisan yang di-offload ke CPU atau hard drive, apakah buffer juga akan di-offload bersama dengan parameter. - fallback_allocation (
bool, opsional, defaultFalse) β Jika alokasi reguler gagal, coba alokasikan modul yang muat dalam batas ukuran menggunakan BFS.
Hitung peta perangkat untuk model tertentu dengan memberikan prioritas pada GPU, kemudian offload ke CPU dan akhirnya offload ke disk, sehingga:
- kami tidak melebihi memori yang tersedia pada GPU mana pun.
- jika offload ke CPU diperlukan, selalu ada ruang tersisa di GPU 0 untuk mengembalikan layer yang di-offload ke CPU yang memiliki ukuran terbesar.
- jika offload ke CPU diperlukan, kami tidak melebihi RAM yang tersedia di CPU.
- jika offload ke disk diperlukan, selalu ada ruang tersisa di CPU untuk mengembalikan layer yang di-offload ke disk yang memiliki ukuran terbesar.
Semua komputasi dilakukan dengan menganalisis ukuran dan dtype dari parameter model. Akibatnya, model dapat berada pada perangkat meta (seperti yang akan terjadi jika diinisialisasi di dalam context manager
init_empty_weights).
accelerate.load_checkpoint_in_model
< source >( model: Modulecheckpoint: str | os.PathLikedevice_map: dict[str, int | str | torch.device] | None = Noneoffload_folder: str | os.PathLike | None = Nonedtype: str | torch.dtype | None = Noneoffload_state_dict: bool = Falseoffload_buffers: bool = Falsekeep_in_fp32_modules: list[str] | None = Noneoffload_8bit_bnb: bool = Falsestrict: bool = Falsefull_state_dict: bool = Truebroadcast_from_rank0: bool = False )
Parameter
- model (
torch.nn.Module) β Model tempat kita ingin memuat checkpoint. - checkpoint (
stratauos.PathLike) β Checkpoint folder yang akan dimuat. Bisa berupa:- path ke file yang berisi state dict model lengkap
- path ke file
.jsonyang berisi indeks untuk checkpoint yang dipecah - path ke folder yang berisi file
.index.jsonunik dan shard dari checkpoint. - path ke folder yang berisi file pytorch_model.bin atau model.safetensors yang unik.
- device_map (
Dict[str, Union[int, str, torch.device]], opsional) β Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Peta ini tidak perlu dirinci hingga ke nama parameter/buffer; begitu nama modul tertentu sudah termasuk di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama. - offload_folder (
stratauos.PathLike, opsional) β Jikadevice_mapberisi nilai"disk", folder tempat bobot akan di-offload. - dtype (
stratautorch.dtype, opsional) β Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat. - offload_state_dict (
bool, opsional, defaultFalse) β JikaTrue, state dict CPU akan secara sementara di-offload ke hard drive untuk menghindari kehabisan RAM CPU jika bobot state dict CPU + shard terbesar tidak muat. - offload_buffers (
bool, opsional, defaultFalse) β Apakah buffer akan disertakan dalam bobot yang di-offload ke disk. - keep_in_fp32_modules(
List[str], opsional) β Daftar modul yang dipertahankan dalam dtypetorch.float32. - offload_8bit_bnb (
bool, opsional) β Apakah akan mengaktifkan offload modul 8-bit ke cpu/disk. - strict (
bool, opsional, defaultnyaFalse) β Apakah akan secara ketat menegakkan bahwa kunci dalam state_dict checkpoint harus cocok dengan kunci dari state_dict model. - full_state_dict (
bool, opsional, defaultnyaTrue) β jika ini diatur keTrue, semua tensor dalam state_dict yang dimuat akan dikumpulkan. Tidak akan ada ShardedTensor dan DTensor dalam state_dict yang dimuat. - broadcast_from_rank0 (
False, opsional, defaultnyaFalse) β ketika opsi iniTrue, sebuahProcessGroupterdistribusi harus diinisialisasi. rank0 harus menerima state_dict lengkap dan akan melakukan broadcast tensor di dalam state_dict satu per satu ke rank lainnya. Rank lainnya akan menerima tensor tersebut dan melakukan sharding (jika berlaku) sesuai dengan shard lokal di model.
Memuat checkpoint (yang mungkin terbagi) di dalam model, dengan kemungkinan mengirim bobot ke perangkat tertentu saat dimuat.
Setelah dimuat di seluruh perangkat, Anda masih perlu memanggil dispatch_model() pada model Anda agar model tersebut dapat dijalankan. Untuk mengelompokkan pemuatan checkpoint dan dispatch dalam satu panggilan tunggal, gunakan load_checkpoint_and_dispatch().
accelerate.utils.load_offloaded_weights
< source >( modelindexoffload_folder )
Memuat bobot dari folder offload ke dalam model.
accelerate.utils.load_state_dict
< source >( checkpoint_filedevice_map = None )
Parameter
- checkpoint_file (
str) β Path ke checkpoint yang akan dimuat. - device_map (
Dict[str, Union[int, str, torch.device]], opsional) β Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Peta ini tidak perlu dirinci hingga ke nama parameter/buffer; begitu nama modul tertentu sudah termasuk di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama.
Muat checkpoint dari file yang diberikan. Jika checkpoint dalam format safetensors dan device map diteruskan, bobot dapat dimuat dengan cepat langsung di GPU.
accelerate.utils.offload_state_dict
< source >( save_dir: str | os.PathLikestate_dict: dict[str, torch.Tensor] )
Offload state dict di folder yang ditentukan.
accelerate.utils.retie_parameters
< source >( modeltied_params )
Reties parameter yang terikat pada model tertentu jika tautannya terputus (misalnya saat menambahkan hook).
accelerate.utils.set_module_tensor_to_device
< source >( module: Moduletensor_name: strdevice: int | str | torch.devicevalue: torch.Tensor | None = Nonedtype: str | torch.dtype | None = Nonefp16_statistics: torch.HalfTensor | None = Nonetied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = Nonenon_blocking: bool = Falseclear_cache: bool = True )
Parameter
- module (
torch.nn.Module) β Modul tempat tensor yang ingin dipindahkan berada. - tensor_name (
str) β Nama lengkap parameter/buffer. - device (
int,stratautorch.device) β Perangkat tempat tensor akan disetel. - value (
torch.Tensor, opsional) β Nilai dari tensor (berguna saat berpindah dari perangkat meta ke perangkat lain). - dtype (
torch.dtype, opsional) β Jika diberikan, nilai parameter akan di-cast kedtypeini. Jika tidak,valueakan di-cast ke dtype dari parameter yang sudah ada di model. - fp16_statistics (
torch.HalfTensor, opsional) β Daftar statistik fp16 yang akan disetel pada modul, digunakan untuk serialisasi model 8 bit. - tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], opsional, default
None) β Peta dari pointer data saat ini ke kamus perangkat ke bobot terikat yang sudah didispatch. Untuk perangkat eksekusi tertentu, parameter ini berguna untuk menggunakan ulang pointer pertama yang tersedia dari bobot bersama pada perangkat tersebut untuk semua lainnya, alih-alih menduplikasi memori. - non_blocking (
bool, opsional, defaultFalse) β JikaTrue, transfer perangkat akan bersifat asinkron terhadap host, jika memungkinkan. - clear_cache (
bool, opsional, defaultTrue) β Apakah cache perangkat akan dibersihkan setelah tensor disetel pada perangkat.
Fungsi bantu untuk mengatur tensor tertentu (parameter atau buffer) dari sebuah modul pada perangkat spesifik (perhatikan bahwa melakukan param.to(device) akan membuat tensor baru yang tidak terhubung ke parameter, itulah mengapa kita membutuhkan fungsi ini).
accelerate.utils.get_module_children_bottom_up
< source >( model: Modulereturn_fqns: bool = False ) β list[torch.nn.Module]
Telusuri model dalam urutan dari bawah ke atas dan kembalikan modul anak dalam urutan tersebut.
Paralel
Ini mencakup utilitas umum yang harus digunakan saat bekerja secara paralel.
accelerate.utils.extract_model_from_parallel
< source >( modelkeep_fp32_wrapper: bool = Truekeep_torch_compile: bool = Truerecursive: bool = False ) β torch.nn.Module
Parameter
- model (
torch.nn.Module) β Model yang akan diekstrak. - keep_fp32_wrapper (
bool, opsional) β Apakah akan menghapus hook presisi campuran dari model. - keep_torch_compile (
bool, opsional) β Apakah akan membuka bungkus model yang dikompilasi. - recursive (
bool, opsional, defaultFalse) β Apakah akan mengekstrak secara rekursif semua kasusmodule.moduledarimodelserta membuka bungkus sublayer anak secara rekursif, bukan hanya kontainer terdistribusi tingkat atas.
Mengembalikan
torch.nn.Module
Model yang diekstrak.
Ekstrak model dari kontainer distribusinya.
accelerate.utils.save
< source >( objfsave_on_each_node: bool = Falsesafe_serialization: bool = False )
Parameter
- obj β Data yang akan disimpan
- f β File (atau objek serupa file) yang akan digunakan untuk menyimpan data
- save_on_each_node (
bool, opsional, defaultnyaFalse) β Apakah hanya menyimpan pada proses utama global - safe_serialization (
bool, opsional, defaultFalse) β Apakah menyimpanobjmenggunakansafetensorsatau cara tradisional PyTorch (yang menggunakanpickle).
Simpan data ke disk. Gunakan sebagai pengganti torch.save().
accelerate.utils.load
< source >( fmap_location = None**kwargs )
Pengganti drop-in yang kompatibel untuk torch.load() yang memungkinkan penggunaan weights_only jika versi torch adalah
2.4.0 atau lebih tinggi. Jika tidak, kwarg akan diabaikan.
Juga akan menambahkan (lalu menghapus) pengecualian untuk array numpy
Memperkenalkan titik pemblokiran dalam skrip, memastikan semua proses telah mencapai titik ini sebelum melanjutkan.
Pastikan semua proses akan mencapai instruksi ini, jika tidak salah satu proses Anda akan menggantung selamanya.
Acak
Utilitas ini berkaitan dengan pengaturan dan sinkronisasi semua keadaan acak.
accelerate.utils.set_seed
< source >( seed: intdevice_specific: bool = Falsedeterministic: bool = False )
Parameter
- seed (
int) β Seed yang akan disetel. - device_specific (
bool, opsional, defaultFalse) β Apakah seed akan sedikit berbeda di setiap perangkat menggunakanself.process_index. - deterministic (
bool, opsional, defaultFalse) β Apakah akan menggunakan algoritma deterministik jika tersedia. Dapat memperlambat pelatihan.
Fungsi bantu untuk perilaku yang dapat direproduksi guna mengatur seed di random, numpy, torch.
accelerate.utils.synchronize_rng_state
< source >( rng_type: str | accelerate.utils.dataclasses.RNGTypegenerator: torch.Generator | None = None )
Sinkronkan RNG bawaan atau RNG akselerator saat ini, yang diidentifikasi berdasarkan tipe perangkatnya.
accelerate.synchronize_rng_states
< source >( rng_types: list[str | accelerate.utils.dataclasses.RNGType]generator: torch.Generator | None = None )
PyTorch XLA
Termasuk di dalamnya adalah utilitas yang berguna saat menggunakan PyTorch dengan XLA.
accelerate.utils.install_xla
< source >( upgrade: bool = False )
Fungsi bantu untuk menginstal roda xla yang sesuai berdasarkan versi torch di Google Colaboratory.
Memuat bobot model
Termasuk di dalamnya adalah utilitas yang berguna untuk memuat checkpoint.
accelerate.load_checkpoint_in_model
< source >( model: Modulecheckpoint: str | os.PathLikedevice_map: dict[str, int | str | torch.device] | None = Noneoffload_folder: str | os.PathLike | None = Nonedtype: str | torch.dtype | None = Noneoffload_state_dict: bool = Falseoffload_buffers: bool = Falsekeep_in_fp32_modules: list[str] | None = Noneoffload_8bit_bnb: bool = Falsestrict: bool = Falsefull_state_dict: bool = Truebroadcast_from_rank0: bool = False )
Parameter
- model (
torch.nn.Module) β Model tempat kita ingin memuat checkpoint. - checkpoint (
stratauos.PathLike) β Checkpoint folder yang akan dimuat. Bisa berupa:- path ke file yang berisi state dict model lengkap
- path ke file
.jsonyang berisi indeks untuk checkpoint yang dipecah - path ke folder yang berisi file
.index.jsonunik dan shard dari checkpoint. - path ke folder yang berisi file pytorch_model.bin atau model.safetensors yang unik.
- device_map (
Dict[str, Union[int, str, torch.device]], opsional) β Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Peta ini tidak perlu dirinci hingga ke nama parameter/buffer; begitu nama modul tertentu sudah termasuk di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama. - offload_folder (
stratauos.PathLike, opsional) β Jikadevice_mapberisi nilai"disk", folder tempat bobot akan di-offload. - dtype (
stratautorch.dtype, opsional) β Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat. - offload_state_dict (
bool, opsional, defaultFalse) β JikaTrue, state dict CPU akan secara sementara di-offload ke hard drive untuk menghindari kehabisan RAM CPU jika bobot state dict CPU + shard terbesar tidak muat. - offload_buffers (
bool, opsional, defaultFalse) β Apakah buffer akan disertakan dalam bobot yang di-offload ke disk. - keep_in_fp32_modules(
List[str], opsional) β Daftar modul yang dipertahankan dalam dtypetorch.float32. - offload_8bit_bnb (
bool, opsional) β Apakah akan mengaktifkan offload modul 8-bit ke cpu/disk. - strict (
bool, opsional, defaultnyaFalse) β Apakah akan secara ketat menegakkan bahwa kunci dalam state_dict checkpoint harus cocok dengan kunci dari state_dict model. - full_state_dict (
bool, opsional, defaultnyaTrue) β jika ini diatur keTrue, semua tensor dalam state_dict yang dimuat akan dikumpulkan. Tidak akan ada ShardedTensor dan DTensor dalam state_dict yang dimuat. - broadcast_from_rank0 (
False, opsional, defaultnyaFalse) β ketika opsi iniTrue, sebuahProcessGroupterdistribusi harus diinisialisasi. rank0 harus menerima state_dict lengkap dan akan melakukan broadcast tensor di dalam state_dict satu per satu ke rank lainnya. Rank lainnya akan menerima tensor tersebut dan melakukan sharding (jika berlaku) sesuai dengan shard lokal di model.
Memuat checkpoint (yang mungkin terbagi) di dalam model, dengan kemungkinan mengirim bobot ke perangkat tertentu saat dimuat.
Setelah dimuat di seluruh perangkat, Anda masih perlu memanggil dispatch_model() pada model Anda agar model tersebut dapat dijalankan. Untuk mengelompokkan pemuatan checkpoint dan dispatch dalam satu panggilan tunggal, gunakan load_checkpoint_and_dispatch().
Kuantisasi
Termasuk di dalamnya adalah utilitas yang berguna untuk mengkuantisasi model.
accelerate.utils.load_and_quantize_model
< source >( model: Modulebnb_quantization_config: BnbQuantizationConfigweights_location: str | os.PathLike | None = Nonedevice_map: dict[str, int | str | torch.device] | None = Noneno_split_module_classes: list[str] | None = Nonemax_memory: dict[int | str, int | str] | None = Noneoffload_folder: str | os.PathLike | None = Noneoffload_state_dict: bool = False ) β torch.nn.Module
Parameter
- model (
torch.nn.Module) β Model input. Model dapat sudah dimuat atau berada di meta device - bnb_quantization_config (
BnbQuantizationConfig) β Parameter kuantisasi bitsandbytes - weights_location (
stratauos.PathLike) β Folder weights_location yang akan dimuat. Bisa berupa:- path ke file yang berisi state dict model lengkap
- path ke file
.jsonyang berisi indeks untuk checkpoint yang dipecah - path ke folder yang berisi file
.index.jsonunik dan shard dari checkpoint. - path ke folder yang berisi file pytorch_model.bin yang unik.
- device_map (
Dict[str, Union[int, str, torch.device]], opsional) β Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Peta ini tidak perlu dirinci hingga ke nama parameter/buffer; begitu nama modul tertentu sudah termasuk di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama. - no_split_module_classes (
List[str], opsional) β Daftar nama kelas layer yang tidak boleh dipecah antar perangkat (misalnya layer apa pun yang memiliki koneksi residual). - max_memory (
Dict, opsional) β Kamus pengidentifikasi perangkat ke memori maksimum. Akan menggunakan memori maksimum yang tersedia jika tidak diatur. - offload_folder (
stratauos.PathLike, opsional) β Jikadevice_mapberisi nilai"disk", folder tempat bobot akan di-offload. - offload_state_dict (
bool, opsional, defaultFalse) β JikaTrue, state dict CPU akan secara sementara di-offload ke hard drive untuk menghindari kehabisan RAM CPU jika bobot state dict CPU + shard terbesar tidak muat.
Mengembalikan
torch.nn.Module
Model terkuantisasi
Fungsi ini akan mengkuantisasi model input dengan konfigurasi terkait yang diteruskan dalam bnb_quantization_config. Jika model berada di perangkat meta, kami akan memuat dan mendistribusikan bobot sesuai dengan device_map yang diteruskan. Jika model sudah dimuat, kami akan mengkuantisasi model dan menempatkan model di GPU,