Accelerate documentation

Fungsi dan kelas utilitas

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

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

kelas accelerate.utils.ComputeEnvironment

< >

( *values )

Mewakili tipe dari lingkungan komputasi.

Nilai:

  • LOCAL_MACHINE β€” perangkat keras klaster privat/kustom.
  • AMAZON_SAGEMAKER β€” Amazon SageMaker sebagai lingkungan komputasi.

kelas accelerate.DistributedType

< >

( *values )

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.

kelas accelerate.utils.DynamoBackend

< >

( *values )

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.

kelas accelerate.utils.LoggerType

< >

( *values )

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

kelas accelerate.utils.PrecisionType

< >

( *values )

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

kelas accelerate.utils.RNGType

< >

( *values )

kelas accelerate.utils.SageMakerDistributedType

< >

( *values )

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

< >

( 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.

Contoh:

from accelerate import Accelerator
from accelerate.utils import AutocastKwargs

kwargs = AutocastKwargs(cache_enabled=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])

kelas accelerate.DistributedDataParallelKwargs

< >

( 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.

Contoh:

from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs

kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])

kelas accelerate.GradScalerKwargs

< >

( 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.

Contoh:

from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

kwargs = GradScalerKwargs(backoff_factor=0.25)
accelerator = Accelerator(kwargs_handlers=[kwargs])

kelas accelerate.InitProcessGroupKwargs

< >

( 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.

from datetime import timedelta
from accelerate import Accelerator
from accelerate.utils import InitProcessGroupKwargs

kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=800))
accelerator = Accelerator(kwargs_handlers=[kwargs])

kelas accelerate.utils.KwargsHandler

< >

( )

Mixin internal yang mengimplementasikan metode to_kwargs() untuk dataclass.

to_kwargs

< >

( )

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

< >

( 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, defaultnya None) β€” Path ke file konfigurasi DeepSpeed atau dict atau objek dari kelas accelerate.utils.deepspeed.HfDeepSpeedConfig.
  • gradient_accumulation_steps (int, defaultnya None) β€” Jumlah langkah untuk mengakumulasi gradien sebelum memperbarui status optimizer. Jika tidak diatur, akan menggunakan nilai langsung dari Accelerator.
  • gradient_clipping (float, defaultnya None) β€” Aktifkan pemotongan gradien dengan nilai.
  • zero_stage (int, defaultnya None) β€” Pilihan yang tersedia adalah 0, 1, 2, 3. Nilai default akan diambil dari variabel lingkungan.
  • is_train_batch_min (bool, defaultnya True) β€” Jika kedua dataloader train & eval ditentukan, ini akan menentukan train_batch_size.
  • offload_optimizer_device (str, defaultnya None) β€” Pilihan yang tersedia adalah none|cpu|nvme. Hanya berlaku dengan ZeRO Stages 2 dan 3.
  • offload_param_device (str, defaultnya None) β€” Pilihan yang tersedia adalah none|cpu|nvme. Hanya berlaku dengan ZeRO Stage 3.
  • offload_optimizer_nvme_path (str, defaultnya None) β€” Pilihan yang tersedia adalah /nvme|/local_nvme. Hanya berlaku dengan ZeRO Stage 3.
  • offload_param_nvme_path (str, defaultnya None) β€” Pilihan yang tersedia adalah /nvme|/local_nvme. Hanya berlaku dengan ZeRO Stage 3.
  • zero3_init_flag (bool, defaultnya None) β€” Flag untuk menunjukkan apakah model 16-bit akan disimpan. Hanya berlaku dengan ZeRO Stage-3.
  • zero3_save_16bit_model (bool, defaultnya None) β€” Flag untuk menunjukkan apakah model 16-bit akan disimpan. Hanya berlaku dengan ZeRO Stage-3.
  • transformer_moe_cls_names (str, defaultnya None) β€” 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

< >

( prefix = ''mismatches = Noneconfig = Nonemust_match = True**kwargs )

Proses konfigurasi DeepSpeed dengan nilai dari kwargs.

pilih

< >

( _from_accelerator_state: bool = False )

Mengatur HfDeepSpeedWeakref untuk menggunakan konfigurasi plugin deepspeed saat ini

kelas accelerate.FullyShardedDataParallelPlugin

< >

( 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, defaultnya 1) β€” 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 berupa str atau instance dari torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Sudah tidak disarankan, gunakan reshard_after_forward sebagai gantinya.
  • reshard_after_forward (Union[str, torch.distributed.fsdp.ShardingStrategy, bool], defaultnya 'FULL_SHARD' untuk fsdp_version=1 dan True untuk fsdp_version=2) β€” Strategi sharding yang akan digunakan. Harus berupa bool jika fsdp_version diatur ke 2, selain itu harus berupa str atau instance dari torch.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 berupa str atau instance dari torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch.
  • mixed_precision_policy (Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], defaultnya None) β€” Konfigurasi untuk mengaktifkan pelatihan presisi campuran dengan FullyShardedDataParallel. Jika Anda melewatkan dict, ia harus memiliki kunci berikut: param_dtype, reduce_dtype, dan buffer_dtype, atau bisa berupa instance dari torch.distributed.fsdp.MixedPrecisionPolicy jika fsdp_version diatur ke 2. Jika Anda melewatkan str, ia harus berupa salah satu nilai berikut: fp8, fp16, bf16, fp32, dan digunakan untuk mengatur param_dtype, reduce_dtype, dan buffer_dtype.
  • auto_wrap_policy (Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults to NO_WRAP) -- A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one of transformer_based_wrap, size_based_wrap, or no_wrap. See torch.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], defaultnya False) β€” Apakah parameter akan di-offload ke CPU. Harus berupa bool atau instance dari torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload atau torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy jika fsdp_version diatur ke 2.
  • ignored_modules (Optional[Union[Iterable[torch.nn.Module], str]], defaultnya None) β€” Daftar modul yang diabaikan saat membungkus dengan FSDP. Saat meneruskan string, modul akan dicocokkan berdasarkan nama menggunakan regex fullmatch. Jika fsdp_version diatur 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 dari full_state_dict, local_state_dict, atau sharded_state_dict.
  • state_dict_config (Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], defaultnya None) β€” Konfigurasi state dict yang akan digunakan. Ditentukan berdasarkan state_dict_type jika tidak diberikan.
  • optim_state_dict_config (Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], defaultnya None) β€” Konfigurasi optim state dict yang akan digunakan. Ditentukan berdasarkan state_dict_type jika tidak diberikan.
  • limit_all_gathers (bool, defaultnya True) β€” 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, defaultnya False) β€” Apakah akan menggunakan parameter asli untuk optimizer.
  • param_init_fn (Optional[Callable[[torch.nn.Module], None], defaultnya None) β€” Callable[torch.nn.Module] -> None yang menentukan bagaimana modul yang saat ini berada di meta device seharusnya diinisialisasi ke perangkat aktual. Hanya berlaku ketika sync_module_states adalah True. Secara default adalah lambda yang memanggil to_empty pada modul.
  • sync_module_states (bool, defaultnya False) β€” 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. Defaultnya False kecuali cpu_ram_efficient_loading adalah True, maka akan dipaksa diaktifkan.
  • forward_prefetch (bool, defaultnya False) β€” 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, defaultnya False) β€” 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, defaultnya None) β€” 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_states harus True.
  • transformer_cls_names_to_wrap (Optional[List[str]], defaultnya None) β€” Daftar nama kelas lapisan transformer yang akan dibungkus. Hanya berlaku ketika auto_wrap_policy adalah transformer_based_wrap.
  • min_num_params (Optional[int], defaultnya None) β€” Jumlah parameter minimum yang harus dimiliki sebuah modul agar dapat dibungkus. Hanya berlaku ketika auto_wrap_policy adalah size_based_wrap.

Plugin ini digunakan untuk mengaktifkan fully sharded data parallelism.

set_auto_wrap_policy

< >

( model )

Diberikan model, membuat auto_wrap_policy berdasarkan kebijakan yang diberikan dan apakah kita dapat menggunakan transformer_cls_to_wrap

set_mixed_precision

< >

( mixed_precisionbuffer_autocast = Falseoverride = False )

Menetapkan kebijakan presisi campuran untuk FSDP

set_state_dict_type

< >

( state_dict_type = None )

Atur konfigurasi state dict berdasarkan StateDictType.

validate_mixed_precision_policy

< >

( )

Memvalidasi kebijakan presisi campuran, yang diabstraksikan agar tidak membawa impor jika tidak diperlukan.

kelas accelerate.utils.GradientAccumulationPlugin

< >

( 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, default True) β€” Apakah langkah scheduler akan disesuaikan untuk memperhitungkan jumlah langkah yang diakumulasi. Harus True jika scheduler yang digunakan belum disesuaikan untuk akumulasi gradien.
  • sync_with_dataloader (bool, opsional, default True) β€” 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 ke True dapat 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.

Contoh:

from accelerate.utils import GradientAccumulationPlugin

gradient_accumulation_plugin = GradientAccumulationPlugin(num_steps=2)
accelerator = Accelerator(gradient_accumulation_plugin=gradient_accumulation_plugin)

kelas accelerate.utils.MegatronLMPlugin

< >

( 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, defaultnya None) β€” Derajat parallelisme tensor.
  • pp_degree (int, defaultnya None) β€” Derajat paralelisme pipeline.
  • num_micro_batches (int, defaultnya None) β€” Jumlah micro-batch.
  • gradient_clipping (float, defaultnya None) β€” Nilai pemotongan gradien berdasarkan L2 Norm global (0 untuk menonaktifkan).
  • sequence_parallelism (bool, defaultnya None) β€” Aktifkan paralelisasi urutan.
  • recompute_activations (bool, defaultnya None) β€” Aktifkan rekomputasi aktivasi selektif.
  • use_distributed_optimizer (bool, defaultnya None) β€” Aktifkan distributed optimizer.
  • pipeline_model_parallel_split_rank (int, defaultnya None) β€” Rank tempat encoder dan decoder harus dipisahkan.
  • num_layers_per_virtual_pipeline_stage (int, defaultnya None) β€” Jumlah lapisan per tahap pipeline virtual.
  • is_train_batch_min (str, defaultnya True) β€” Jika kedua dataloader tran & eval ditentukan, ini akan menentukan micro_batch_size.
  • train_iters (int, defaultnya None) β€” Total jumlah sampel untuk dilatih di seluruh run pelatihan. Perhatikan bahwa salah satu dari train-iters atau train-samples harus disediakan saat menggunakan MegatronLMDummyScheduler.
  • train_samples (int, defaultnya None) β€” Total jumlah sampel untuk dilatih di seluruh run pelatihan. Perhatikan bahwa salah satu dari train-iters atau train-samples harus disediakan saat menggunakan MegatronLMDummyScheduler.
  • weight_decay_incr_style (str, defaultnya 'constant') β€” Fungsi inkremen weight decay. choices=[β€œconstant”, β€œlinear”, β€œcosine”].
  • start_weight_decay (float, defaultnya None) β€” Koefisien weight decay awal untuk regularisasi L2.
  • end_weight_decay (float, defaultnya None) β€” 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, defaultnya None) β€” Jumlah iterasi untuk peluruhan laju belajar. Jika None, defaultnya adalah train_iters.
  • lr_decay_samples (int, defaultnya None) β€” Jumlah sampel untuk peluruhan laju belajar. Jika None, defaultnya adalah train_samples.
  • lr_warmup_iters (int, defaultnya None) β€” Jumlah iterasi untuk melakukan pemanasan linear pada learning rate.
  • lr_warmup_samples (int, defaultnya None) β€” Jumlah sampel untuk melakukan pemanasan linear pada learning rate.
  • lr_warmup_fraction (float, defaultnya None) β€” Fraksi dari lr-warmup-(iters/samples) untuk melakukan warmup linear pada learning rate.
  • min_lr (float, defaultnya 0) β€” Nilai minimum untuk learning rate. Scheduler memotong nilai di bawah ambang batas ini.
  • consumed_samples (List, defaultnya None) β€” Jumlah sampel yang dikonsumsi dalam urutan yang sama dengan dataloaders pada pemanggilan accelerator.prepare.
  • no_wd_decay_cond (Optional, defaultnya None) β€” Kondisi untuk menonaktifkan weight decay.
  • scale_lr_cond (Optional, defaultnya None) β€” Kondisi untuk menskalakan learning rate.
  • lr_mult (float, defaultnya 1.0) β€” Pengali learning rate.
  • megatron_dataset_flag (bool, defaultnya False) β€” Apakah format dataset mengikuti format Indexed/Cached/MemoryMapped dari Megatron-LM.
  • seq_length (int, defaultnya None) β€” Panjang maksimum urutan yang akan diproses.
  • encoder_seq_length (int, defaultnya None) β€” Panjang maksimum urutan yang akan diproses oleh encoder.
  • decoder_seq_length (int, defaultnya None) β€” Panjang maksimum urutan untuk diproses oleh decoder.
  • tensorboard_dir (str, defaultnya None) β€” Path untuk menyimpan log tensorboard.
  • set_all_logging_options (bool, defaultnya False) β€” Apakah akan mengatur semua opsi log.
  • eval_iters (int, defaultnya 100) β€” Jumlah iterasi yang dijalankan untuk evaluasi validasi/tes.
  • eval_interval (int, defaultnya 1000) β€” Interval antara menjalankan evaluasi pada set validasi.
  • return_logits (bool, defaultnya False) β€” Apakah akan mengembalikan logits dari model.
  • custom_train_step_class (Optional, defaultnya None) β€” Kelas langkah pelatihan kustom.
  • custom_train_step_kwargs (Optional, defaultnya None) β€” Kwargs langkah pelatihan kustom.
  • custom_model_provider_function (Optional, defaultnya None) β€” Fungsi penyedia model kustom.
  • custom_prepare_model_function (Optional, defaultnya None) β€” Fungsi prepare model kustom.
  • custom_megatron_datasets_provider_function (Optional, defaultnya None) β€” Fungsi penyedia dataset train_valid_test megatron kustom.
  • custom_get_batch_function (Optional, defaultnya None) β€” Fungsi get batch kustom.
  • custom_loss_function (Optional, defaultnya None) β€” Fungsi loss kustom.
  • other_megatron_args (Optional, defaultnya None) β€” 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

< >

( backend: DynamoBackend = Nonemode: str = Nonefullgraph: bool = Nonedynamic: bool = Noneoptions: Any = Nonedisable: bool = Falseuse_regional_compilation: bool = None )

Parameter

  • backend (DynamoBackend, defaultnya None) β€” Backend Dynamo yang valid. Lihat https://pytorch.org/docs/stable/torch.compiler.html untuk detail lebih lanjut.
  • mode (str, defaultnya None) β€” Pilihan yang tersedia adalah β€˜default’, β€˜reduce-overhead’, atau β€˜max-autotune’.
  • fullgraph (bool, defaultnya None) β€” Apakah model boleh dipecah menjadi beberapa subgraf.
  • dynamic (bool, defaultnya None) β€” Apakah akan menggunakan bentuk dinamis untuk pelacakan.
  • options (Any, defaultnya None) β€” Kamus opsi untuk diteruskan ke backend.
  • disable (bool, defaultnya False) β€” Mengubah torch.compile() menjadi no-op untuk pengujian
  • use_regional_compilation (bool, defaultnya None) β€” 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, pada GPT2LMHeadModel, blok/kelas yang berulang adalah GPT2Block, dan dapat diakses sebagai model.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

< >

( 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, defaultnya False) β€” Aktifkan kuantisasi 8bit.
  • llm_int8_threshold (float, defaultnya 6.0) β€” Nilai ambang batas outliner. Hanya relevan ketika load_in_8bit=True.
  • load_in_4bit (bool, defaultnya False) β€” Aktifkan kuantisasi 4bit.
  • bnb_4bit_quant_type (str, defaultnya fp4) β€” Menetapkan tipe data kuantisasi pada lapisan bnb.nn.Linear4Bit. Opsinya adalah {β€˜fp4’,β€˜np4’}.
  • bnb_4bit_use_double_quant (bool, defaultnya False) β€” Aktifkan kuantisasi bersarang di mana konstanta kuantisasi dari kuantisasi pertama dikuantisasi lagi.
  • bnb_4bit_compute_dtype (bool, defaultnya fp16) β€” 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, defaultnya None) β€” Ini mengatur dtype dari lapisan non-kuantisasi yang tersisa. Perpustakaan bitsandbytes menyarankan untuk mengatur nilainya ke torch.float16 untuk model 8 bit dan menggunakan dtype yang sama dengan dtype komputasi untuk model 4 bit.
  • skip_modules (List[str], defaultnya None) β€” Daftar eksplisit modul yang tidak akan dikuantisasi. dtype dari modul-modul ini akan menjadi torch_dtype.
  • keep_in_fp32_modules (List, defaultnya None) β€” Daftar eksplisit modul yang tidak kami kuantisasi. Kami menjaganya tetap dalam torch.float32.

Plugin untuk mengaktifkan kuantisasi 4bit dan 8bit BitsAndBytes

kelas accelerate.DataLoaderConfiguration

< >

( 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, defaultnya False) β€” Apakah accelerator harus membagi batch yang dihasilkan oleh dataloaders di antara perangkat. Jika True, ukuran batch aktual yang digunakan akan sama di semua jenis proses terdistribusi, tetapi harus berupa kelipatan bulat dari num_processes yang Anda gunakan. Jika False, ukuran batch aktual yang digunakan akan menjadi yang diatur dalam skrip Anda dikalikan dengan jumlah proses.
  • dispatch_batches (bool, defaultnya None) β€” Jika diset ke True, dataloader yang disiapkan oleh Accelerator hanya diiterasi pada proses utama, lalu batch dipecah dan disiarkan ke setiap proses. Akan default ke True untuk DataLoader yang dataset dasarnya adalah IterableDataset, False selain itu.
  • even_batches (bool, defaultnya True) β€” Jika diset ke True, 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, default False) β€” 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, defaultnya None) β€” Seed yang akan digunakan untuk generator dasar saat menggunakan use_seedable_sampler. Jika None, generator akan menggunakan seed default saat ini dari torch.
  • non_blocking (bool, defaultnya False) β€” Jika diatur ke True, 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 memiliki pin_memory yang diatur ke True agar berfungsi dengan baik.
  • use_stateful_dataloader (bool, defaultnya False) β€” Jika diset ke True, dataloader yang disiapkan oleh Accelerator akan didukung oleh torchdata.StatefulDataLoader. Hal ini memerlukan instalasi torchdata versi 0.8.0 atau lebih tinggi yang mendukung StatefulDataLoader.

Konfigurasi untuk item terkait dataloader saat memanggil accelerator.prepare.

kelas accelerate.utils.ProjectConfiguration

< >

( 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, defaultnya None) β€” Path ke direktori untuk menyimpan data.
  • logging_dir (str, defaultnya None) β€” Path ke direktori untuk menyimpan log dari logger yang kompatibel secara lokal. Jika None, defaultnya adalah project_dir.
  • automatic_checkpoint_naming (bool, defaultnya False) β€” Apakah state yang disimpan harus diberi nama secara otomatis dan iteratif.
  • total_limit (int, defaultnya None) β€” Jumlah maksimum total state yang disimpan untuk dipertahankan.
  • iteration (int, defaultnya 0) β€” Iterasi simpan saat ini.
  • save_on_each_node (bool, defaultnya False) β€” 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.

set_directories

< >

( project_dir: str | None = None )

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

< >

( tensorfrom_process: int = 0 )

Parameter

  • tensor (nested list/tuple/dictionary of torch.Tensor) β€” Data yang akan dikumpulkan.
  • from_process (int, opsional, default 0) β€” Proses yang menjadi sumber pengiriman data

Broadcast tensor secara rekursif dalam list/tuple/dictionary tensor bersarang ke semua perangkat.

accelerate.utils.broadcast_object_list

< >

( object_listfrom_process: int = 0 )

Parameter

  • object_list (list of picklable objects) β€” Daftar objek yang akan di-broadcast. Daftar ini akan dimodifikasi secara inplace.
  • from_process (int, opsional, default 0) β€” Proses yang menjadi sumber pengiriman data.

Broadcast daftar objek yang dapat di-pickle dari satu proses ke proses lainnya.

accelerate.utils.concatenate

< >

( datadim = 0 )

Parameter

  • data (nested list/tuple/dictionary of lists of tensors torch.Tensor) — The data to concatenate.
  • dim (int, opsional, default 0) β€” Dimensi tempat penggabungan (concatenation) dilakukan.

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_outputs_to_fp32

< >

( model_forward )

accelerate.utils.convert_to_fp32

< >

( tensor )

Parameter

  • tensor (nested list/tuple/dictionary of torch.Tensor) β€” Data yang akan dikonversi dari FP16/BF16 ke FP32.

Mengonversi secara rekursif elemen-elemen dalam daftar/tuple/dictionary tensor yang bersarang dari presisi FP16/BF16 ke FP32.

accelerate.utils.gather

< >

( tensor )

Parameter

  • tensor (nested list/tuple/dictionary of torch.Tensor) β€” Data yang akan dikumpulkan.

Kumpulkan tensor secara rekursif dalam daftar/tuple/dictionary tensor bersarang dari semua perangkat.

accelerate.utils.gather_object

< >

( object: Any )

Parameter

  • object (nested list/tuple/dictionary of picklable object) β€” Data yang akan dikumpulkan.

Kumpulkan objek secara rekursif dalam daftar/tuple/dictionary objek bersarang dari semua perangkat.

accelerate.utils.get_grad_scaler

< >

( distributed_type: DistributedType = None**kwargs )

Parameter

  • distributed_type (DistributedType, opsional, default None) β€” Jenis lingkungan terdistribusi.
  • kwargs β€” Argumen tambahan untuk konstruktor GradScaler yang digunakan.

Helper generik yang akan menginisialisasi implementasi GradScaler yang benar berdasarkan lingkungan dan mengembalikannya.

accelerate.utils.get_mixed_precision_context_manager

< >

( native_amp: bool = Falseautocast_kwargs: AutocastKwargs = None )

Parameter

  • native_amp (bool, opsional, default False) β€” Apakah mixed precision benar-benar diaktifkan.

Kembalikan context manager untuk autocasting presisi campuran

accelerate.utils.listify

< >

( data )

Parameter

  • data (nested list/tuple/dictionary of torch.Tensor) β€” Data yang akan dikonversi menjadi angka biasa.

Mencari tensor secara rekursif dalam list/tuple/dictionary bersarang dan mengonversinya menjadi list angka.

accelerate.utils.pad_across_processes

< >

( 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, default False) β€” 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

< >

( 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 menerapkan func
  • *args β€” Argumen posisional yang akan diteruskan ke func saat diterapkan pada data yang telah diurai.
  • test_type (Callable[[Any], bool], opsional, defaultnya is_torch_tensor) β€” Predikat yang menentukan apakah func harus diterapkan pada objek daun tertentu.
  • error_on_other_type (bool, opsional, defaultnya False) β€” Apakah akan mengembalikan error atau tidak jika setelah unpacking data, kita mendapatkan objek yang test_type mengembalikan False. Jika False, fungsi akan membiarkan objek semacam itu tetap tidak berubah.
  • **kwargs (argumen kata kunci tambahan, opsional) β€” Argumen kata kunci yang akan diteruskan ke func saat 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

< >

( 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

< >

( 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, default False) β€” Jika True, transfer ke perangkat dilakukan secara asinkron, yang memungkinkan pergerakan data tumpang tindih dengan komputasi. Hanya efektif jika perangkat mendukungnya (mis. CUDA).
  • skip_keys (str atau List[str], opsional) β€” Kunci atau daftar kunci dalam dictionary tensor yang nilainya tidak boleh dikirim ke device yang 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

< >

( datatensor_sliceprocess_index = Nonenum_processes = None )

Parameter

  • data (nested list/tuple/dictionary of torch.Tensor) β€” Data yang akan dipotong.
  • tensor_slice (slice) β€” Slice yang akan diambil.

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.

accelerate.utils.is_bf16_available

< >

( ignore_tpu = False )

Memeriksa apakah bf16 didukung, dengan opsi untuk mengabaikan TPU

accelerate.utils.is_mps_available

< >

( min_version = '1.12' )

Memeriksa apakah perangkat MPS tersedia. Versi minimum yang diperlukan adalah 1.12.

accelerate.utils.is_npu_available

( check_device = False )

Memeriksa apakah torch_npu terinstal dan, jika perlu, apakah ada NPU di lingkungan

accelerate.utils.is_torch_version

< >

( operation: strversion: str )

Parameter

  • operation (str) β€” Representasi string dari sebuah operator, seperti ">" atau "<="
  • version (str) β€” Versi string dari PyTorch

Membandingkan versi PyTorch saat ini dengan referensi tertentu menggunakan operasi.

accelerate.utils.is_torch_xla_available

( check_is_tpu = Falsecheck_is_gpu = False )

Periksa apakah torch_xla tersedia. Untuk melatih tugas pytorch native di lingkungan dengan torch xla yang terinstal, setel USE_TORCH_XLA ke false.

accelerate.utils.is_xpu_available

( check_device = False )

Memeriksa apakah akselerasi XPU tersedia melalui PyTorch standar (>=2.7) dan apakah ada XPU di lingkungan

Manipulasi Lingkungan

accelerate.utils.patch_environment

< >

( **kwargs )

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.

Contoh:

>>> import os
>>> from accelerate.utils import patch_environment

>>> with patch_environment(FOO="bar"):
...     print(os.environ["FOO"])  # prints "bar"
>>> print(os.environ["FOO"])  # raises KeyError

accelerate.utils.clear_environment

< >

( )

Manajer konteks yang akan menghapus variabel lingkungan secara sementara.

Saat konteks ini keluar, variabel lingkungan sebelumnya akan kembali.

Contoh:

>>> import os
>>> from accelerate.utils import clear_environment

>>> os.environ["FOO"] = "bar"
>>> with clear_environment():
...     print(os.environ)
...     os.environ["FOO"] = "new_bar"
...     print(os.environ["FOO"])
{}
new_bar

>>> print(os.environ["FOO"])
bar

accelerate.commands.config.default.write_basic_config

< >

( 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, defaultnya default_json_config_file) β€” Lokasi penyimpanan kustom opsional. Seharusnya diteruskan ke --config_file saat menggunakan accelerate launch. Lokasi default berada di dalam folder cache huggingface (~/.cache/huggingface) tetapi dapat ditimpa dengan mengatur variabel lingkungan HF_HOME, diikuti oleh accelerate/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.

accelerate.utils.set_numa_affinity

( local_process_index: intverbose: bool | None = None )

Parameter

  • local_process_index (int) β€” Indeks proses saat ini pada server saat ini.
  • verbose (bool, opsional) β€” Apakah akan mencetak penugasan inti cpu baru untuk setiap proses. Jika ACCELERATE_DEBUG_MODE diaktifkan, akan default ke True.

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

< >

( local_process_index: intverbose: bool | None = None )

Parameter

  • local_process_index (int) β€” Indeks proses saat ini pada server saat ini.
  • verbose (bool, opsional) β€” Apakah akan mencatat penugasan setiap CPU. Jika ACCELERATE_DEBUG_MODE diaktifkan, nilai default akan menjadi True.

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.

accelerate.utils.purge_accelerate_environment

< >

( func_or_cls )

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

< >

( 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) sebagai int.

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.

Contoh:

>>> from accelerate.utils import find_executable_batch_size


>>> @find_executable_batch_size(starting_batch_size=128)
... def train(batch_size, model, optimizer):
...     ...


>>> train(model, optimizer)

Modeling

Utilitas ini berkaitan dengan interaksi dengan model PyTorch

accelerate.utils.calculate_maximum_sizes

< >

( model: Module )

Menghitung ukuran total model dan lapisan terbesarnya

accelerate.utils.compute_module_sizes

< >

( 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

< >

( 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, default False) β€” Apakah akan mengekstrak secara rekursif semua kasus module.module dari model serta 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

< >

( 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 (str atau torch.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

< >

( 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 oleh compute_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

< >

( 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 (str atau torch.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, default False) β€” Apakah akan memberikan pernyataan debugging saat fungsi membangun device_map.
  • clean_result (bool, opsional, default True) β€” Bersihkan device_map hasil akhir dengan mengelompokkan semua submodul yang berada di perangkat yang sama.
  • offload_buffers (bool, opsional, default False) β€” Pada lapisan yang di-offload ke CPU atau hard drive, apakah buffer juga akan di-offload bersama dengan parameter.
  • fallback_allocation (bool, opsional, default False) β€” 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

< >

( 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 (str atau os.PathLike) β€” Checkpoint folder yang akan dimuat. Bisa berupa:
    • path ke file yang berisi state dict model lengkap
    • path ke file .json yang berisi indeks untuk checkpoint yang dipecah
    • path ke folder yang berisi file .index.json unik 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 (str atau os.PathLike, opsional) β€” Jika device_map berisi nilai "disk", folder tempat bobot akan di-offload.
  • dtype (str atau torch.dtype, opsional) β€” Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat.
  • offload_state_dict (bool, opsional, default False) β€” Jika True, 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, default False) β€” Apakah buffer akan disertakan dalam bobot yang di-offload ke disk.
  • keep_in_fp32_modules(List[str], opsional) β€” Daftar modul yang dipertahankan dalam dtype torch.float32.
  • offload_8bit_bnb (bool, opsional) β€” Apakah akan mengaktifkan offload modul 8-bit ke cpu/disk.
  • strict (bool, opsional, defaultnya False) β€” Apakah akan secara ketat menegakkan bahwa kunci dalam state_dict checkpoint harus cocok dengan kunci dari state_dict model.
  • full_state_dict (bool, opsional, defaultnya True) β€” jika ini diatur ke True, 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, defaultnya False) β€” ketika opsi ini True, sebuah ProcessGroup terdistribusi 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

< >

( modelindexoffload_folder )

Parameter

  • model (torch.nn.Module) β€” Model tempat bobot akan dimuat.
  • index (dict) β€” Kamus yang berisi nama parameter dan metadata-nya untuk setiap parameter yang di-offload dari model.
  • offload_folder (str) β€” Folder tempat bobot yang di-offload disimpan.

Memuat bobot dari folder offload ke dalam model.

accelerate.utils.load_state_dict

< >

( 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

< >

( save_dir: str | os.PathLikestate_dict: dict[str, torch.Tensor] )

Parameter

  • save_dir (str atau os.PathLike) β€” Direktori tempat state dict di-offload.
  • state_dict (Dict[str, torch.Tensor]) β€” Kamus tensor untuk di-offload.

Offload state dict di folder yang ditentukan.

accelerate.utils.retie_parameters

< >

( modeltied_params )

Parameter

  • model (torch.nn.Module) β€” Model tempat parameter akan diikat ulang.
  • tied_params (List[List[str]]) β€” Pemetaan nama parameter ke nama parameter yang terikat, sebagaimana diperoleh oleh find_tied_parameters.

Reties parameter yang terikat pada model tertentu jika tautannya terputus (misalnya saat menambahkan hook).

accelerate.utils.set_module_tensor_to_device

< >

( 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, str atau torch.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 ke dtype ini. Jika tidak, value akan 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, default False) β€” Jika True, transfer perangkat akan bersifat asinkron terhadap host, jika memungkinkan.
  • clear_cache (bool, opsional, default True) β€” 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

< >

( model: Modulereturn_fqns: bool = False ) β†’ list[torch.nn.Module]

Parameter

  • model (torch.nn.Module) β€” model yang akan diambil anak-anaknya

Mengembalikan

list[torch.nn.Module]

daftar modul anak dari model dalam urutan bottom-up. Elemen terakhir adalah model itu sendiri.

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

< >

( 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, default False) β€” Apakah akan mengekstrak secara rekursif semua kasus module.module dari model serta 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

< >

( 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, defaultnya False) β€” Apakah hanya menyimpan pada proses utama global
  • safe_serialization (bool, opsional, default False) β€” Apakah menyimpan obj menggunakan safetensors atau cara tradisional PyTorch (yang menggunakan pickle).

Simpan data ke disk. Gunakan sebagai pengganti torch.save().

accelerate.utils.load

< >

( fmap_location = None**kwargs )

Parameter

  • f β€” File (atau objek serupa file) yang digunakan untuk memuat data
  • map_location β€” fungsi, torch.device, string, atau dict yang menentukan cara memetakan ulang lokasi penyimpanan
  • **kwargs β€” Argumen kata kunci tambahan untuk diteruskan ke torch.load().

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

accelerate.utils.wait_for_everyone

< >

( )

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

< >

( seed: intdevice_specific: bool = Falsedeterministic: bool = False )

Parameter

  • seed (int) β€” Seed yang akan disetel.
  • device_specific (bool, opsional, default False) β€” Apakah seed akan sedikit berbeda di setiap perangkat menggunakan self.process_index.
  • deterministic (bool, opsional, default False) β€” 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

< >

( 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

< >

( 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

< >

( upgrade: bool = False )

Parameter

  • upgrade (bool, opsional, default False) β€” Apakah akan meng-upgrade torch dan menginstal roda torch_xla terbaru.

Fungsi bantu untuk menginstal roda xla yang sesuai berdasarkan versi torch di Google Colaboratory.

Contoh:

>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)

Memuat bobot model

Termasuk di dalamnya adalah utilitas yang berguna untuk memuat checkpoint.

accelerate.load_checkpoint_in_model

< >

( 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 (str atau os.PathLike) β€” Checkpoint folder yang akan dimuat. Bisa berupa:
    • path ke file yang berisi state dict model lengkap
    • path ke file .json yang berisi indeks untuk checkpoint yang dipecah
    • path ke folder yang berisi file .index.json unik 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 (str atau os.PathLike, opsional) β€” Jika device_map berisi nilai "disk", folder tempat bobot akan di-offload.
  • dtype (str atau torch.dtype, opsional) β€” Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat.
  • offload_state_dict (bool, opsional, default False) β€” Jika True, 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, default False) β€” Apakah buffer akan disertakan dalam bobot yang di-offload ke disk.
  • keep_in_fp32_modules(List[str], opsional) β€” Daftar modul yang dipertahankan dalam dtype torch.float32.
  • offload_8bit_bnb (bool, opsional) β€” Apakah akan mengaktifkan offload modul 8-bit ke cpu/disk.
  • strict (bool, opsional, defaultnya False) β€” Apakah akan secara ketat menegakkan bahwa kunci dalam state_dict checkpoint harus cocok dengan kunci dari state_dict model.
  • full_state_dict (bool, opsional, defaultnya True) β€” jika ini diatur ke True, 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, defaultnya False) β€” ketika opsi ini True, sebuah ProcessGroup terdistribusi 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

< >

( 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 (str atau os.PathLike) β€” Folder weights_location yang akan dimuat. Bisa berupa:
    • path ke file yang berisi state dict model lengkap
    • path ke file .json yang berisi indeks untuk checkpoint yang dipecah
    • path ke folder yang berisi file .index.json unik 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 (str atau os.PathLike, opsional) β€” Jika device_map berisi nilai "disk", folder tempat bobot akan di-offload.
  • offload_state_dict (bool, opsional, default False) β€” Jika True, 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,

Update on GitHub