Hugging Face's logo

Accelerate documentation

Các hàm và lớp tiện ích

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Các hàm và lớp tiện ích

Dưới đây là một số hàm tiện ích mà 🤗 Accelerate cung cấp, được phân loại theo trường hợp sử dụng.

Hằng số

Các hằng số được sử dụng xuyên suốt 🤗 Accelerate để tham chiếu

Dưới đây là các hằng số được sử dụng khi sử dụng 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

Dưới đây là các hằng số được sử dụng khi sử dụng 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"

Lớp Dữ liệu

Đây là các dataclass cơ bản được sử dụng xuyên suốt trong 🤗 Accelerate và chúng có thể được truyền vào dưới dạng tham số.

Độc lập

Đây là các dataclass độc lập được sử dụng cho các kiểm tra, chẳng hạn như loại hệ thống phân tán đang được sử dụng

lớp accelerate.utils.ComputeEnvironment

< >

( *values )

Đại diện cho một kiểu của môi trường tính toán.

Giá trị:

  • LOCAL_MACHINE — phần cứng cụm máy riêng/tùy chỉnh.
  • AMAZON_SAGEMAKER — Amazon SageMaker với tư cách là môi trường tính toán.

lớp accelerate.DistributedType

< >

( *values )

Đại diện cho một kiểu môi trường phân tán.

Giá trị:

  • NO — Không phải môi trường phân tán, chỉ là một tiến trình duy nhất.
  • MULTI_CPU — Phân tán trên nhiều nút CPU.
  • MULTI_GPU — Phân tán trên nhiều GPU.
  • MULTI_MLU — Phân tán trên nhiều MLU.
  • MULTI_SDAA — Phân tán trên nhiều SDAAs.
  • MULTI_MUSA — Phân tán trên nhiều MUSA.
  • MULTI_NPU — Phân tán trên nhiều NPU.
  • MULTI_XPU — Phân tán trên nhiều XPU.
  • MULTI_HPU — Phân tán trên nhiều HPU.
  • MULTI_NEURON — Phân tán trên nhiều lõi Neuron.
  • DEEPSPEED — Sử dụng DeepSpeed.
  • FSDP — Sử dụng Fully Sharded Data Parallelism (FSDP).
  • XLA — Sử dụng TorchXLA.
  • MEGATRON_LM — Sử dụng Megatron-LM.

lớp accelerate.utils.DynamoBackend

< >

( *values )

Đại diện cho một backend dynamo (xem https://pytorch.org/docs/stable/torch.compiler.html).

Giá trị:

  • KHÔNG — Không sử dụng torch dynamo.
  • EAGER — Sử dụng PyTorch để chạy GraphModule đã trích xuất. Điều này khá hữu ích trong việc gỡ lỗi các vấn đề của TorchDynamo.
  • AOT_EAGER — Sử dụng AotAutograd mà không có trình biên dịch, tức là chỉ dùng PyTorch eager cho các đồ thị forward và backward đã được trích xuất bởi AotAutograd. Điều này hữu ích cho việc gỡ lỗi và khó có thể mang lại hiệu suất cao hơn.
  • INDUCTOR — Sử dụng backend TorchInductor với AotAutograd và cudagraphs bằng cách tận dụng các kernel Triton được codegen. Đọc thêm
  • AOT_TS_NVFUSER — nvFuser với AotAutograd/TorchScript. Đọc thêm
  • NVPRIMS_NVFUSER — nvFuser với PrimTorch. Đọc thêm
  • CUDAGRAPHS — cudagraphs với AotAutograd. Đọc thêm
  • OFI — Sử dụng Torchscript optimize_for_inference. Chỉ dành cho suy luận. Đọc thêm
  • FX2TRT — Sử dụng Nvidia TensorRT để tối ưu hóa suy luận. Chỉ dành cho suy luận. Đọc thêm
  • ONNXRT — Sử dụng ONNXRT để suy luận trên CPU/GPU. Chỉ dành cho suy luận. Đọc thêm
  • TENSORRT — Sử dụng ONNXRT để chạy TensorRT cho các tối ưu hóa suy luận. Đọc thêm
  • AOT_TORCHXLA_TRACE_ONCE — Sử dụng Pytorch/XLA với tối ưu hóa TorchDynamo, dành cho huấn luyện. Đọc thêm
  • TORCHXLA_TRACE_ONCE — Sử dụng Pytorch/XLA với tối ưu hóa TorchDynamo, dành cho suy luận. Đọc thêm
  • TVM — Sử dụng Apache TVM để tối ưu hóa suy luận. Đọc thêm
  • HPU_BACKEND — Sử dụng HPU backend cho các tối ưu hóa suy luận.
  • NEURON — Sử dụng backend AWS Neuron cho Trainium/Inferentia.

lớp accelerate.utils.LoggerType

< >

( *values )

Đại diện cho một loại trình theo dõi thí nghiệm được hỗ trợ

Giá trị:

  • TẤT CẢ — tất cả các trình theo dõi khả dụng trong môi trường được hỗ trợ
  • TENSORBOARD — TensorBoard như một công cụ theo dõi thí nghiệm
  • WANDB — wandb như một công cụ theo dõi thí nghiệm
  • TRACKIO — trackio như một công cụ theo dõi thí nghiệm
  • COMETML — comet_ml như một trình theo dõi thí nghiệm
  • MLFLOW — mlflow như một trình theo dõi thí nghiệm
  • CLEARML — clearml như một công cụ theo dõi thí nghiệm
  • DVCLIVE — dvclive như một công cụ theo dõi thí nghiệm
  • SWANLAB — swanlab như một công cụ theo dõi thí nghiệm

lớp accelerate.utils.PrecisionType

< >

( *values )

Đại diện cho một kiểu độ chính xác được sử dụng cho các giá trị số dấu phẩy động

Giá trị:

  • KHÔNG — sử dụng độ chính xác đầy đủ (FP32)
  • FP16 — sử dụng độ chính xác nửa
  • BF16 — sử dụng độ chính xác brain floating point

lớp accelerate.utils.RNGType

< >

( *values )

lớp accelerate.utils.SageMakerDistributedType

< >

( *values )

Đại diện cho một kiểu môi trường phân tán.

Giá trị:

  • NO — Không phải môi trường phân tán, chỉ là một tiến trình duy nhất.
  • DATA_PARALLEL — sử dụng sagemaker distributed data parallelism.
  • MODEL_PARALLEL — sử dụng sagemaker distributed model parallelism.

Kwargs

Đây là các đối số cấu hình được dành cho các tương tác cụ thể trong hệ sinh thái PyTorch mà Accelerate xử lý ở phía sau.

lớp accelerate.AutocastKwargs

< >

( enabled: bool = Truecache_enabled: bool | None = None )

Sử dụng đối tượng này trong Accelerator của bạn để tùy chỉnh cách torch.autocast hoạt động. Vui lòng tham khảo tài liệu của context manager này để biết thêm thông tin về từng tham số.

Ví dụ:

from accelerate import Accelerator
from accelerate.utils import AutocastKwargs

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

lớp 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> )

Sử dụng đối tượng này trong Accelerator của bạn để tùy chỉnh cách mô hình của bạn được bọc trong torch.nn.parallel.DistributedDataParallel. Vui lòng tham khảo tài liệu của wrapper này để biết thêm thông tin về từng đối số.

Ví dụ:

from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs

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

lớp accelerate.GradScalerKwargs

< >

( init_scale: float = 65536.0growth_factor: float = 2.0backoff_factor: float = 0.5growth_interval: int = 2000enabled: bool = True )

Sử dụng đối tượng này trong Accelerator của bạn để tùy chỉnh hành vi của độ chính xác hỗn hợp, cụ thể là cách tạo ra torch.amp.GradScaler hoặc torch.cuda.amp.GradScaler được sử dụng. Vui lòng tham khảo tài liệu của scaler này để biết thêm thông tin về từng đối số.

Ví dụ:

from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

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

lớp accelerate.InitProcessGroupKwargs

< >

( backend: str | None = 'nccl'init_method: str | None = Nonetimeout: datetime.timedelta | None = None )

Sử dụng đối tượng này trong Accelerator của bạn để tùy chỉnh việc khởi tạo các tiến trình phân tán. Vui lòng tham khảo tài liệu của phương thức này để biết thêm thông tin về từng đối số.

Lưu ý: Nếu timeout được đặt thành None, giá trị mặc định sẽ dựa trên cách backend được cấu hình.

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

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

lớp accelerate.utils.KwargsHandler

< >

( )

Mixin nội bộ triển khai phương thức to_kwargs() cho một dataclass.

to_kwargs

< >

( )

Trả về một từ điển chứa các thuộc tính có giá trị khác với giá trị mặc định của lớp này.

Plugins

Đây là các plugin có thể được truyền vào đối tượng Accelerator. Mặc dù chúng được định nghĩa ở các phần khác trong tài liệu, để tiện lợi, tất cả đều có thể xem tại đây:

lớp 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 )

Tham số

  • hf_ds_config (Any, mặc định là None) — Đường dẫn đến tệp cấu hình DeepSpeed hoặc dict hoặc một đối tượng của lớp accelerate.utils.deepspeed.HfDeepSpeedConfig.
  • gradient_accumulation_steps (int, mặc định là None) — Số bước để tích lũy gradient trước khi cập nhật trạng thái của optimizer. Nếu không được đặt, sẽ sử dụng giá trị từ Accelerator trực tiếp.
  • gradient_clipping (float, mặc định là None) — Bật cắt gradient với giá trị.
  • zero_stage (int, mặc định là None) — Các tùy chọn có thể là 0, 1, 2, 3. Giá trị mặc định sẽ được lấy từ biến môi trường.
  • is_train_batch_min (bool, mặc định là True) — Nếu cả train & eval dataloaders đều được chỉ định, tham số này sẽ quyết định train_batch_size.
  • offload_optimizer_device (str, mặc định là None) — Các tùy chọn khả dụng là none|cpu|nvme. Chỉ áp dụng với ZeRO Stages 2 và 3.
  • offload_param_device (str, mặc định là None) — Các tùy chọn có thể là none|cpu|nvme. Chỉ áp dụng với ZeRO Stage 3.
  • offload_optimizer_nvme_path (str, mặc định là None) — Các tùy chọn có thể là /nvme|/local_nvme. Chỉ áp dụng với ZeRO Stage 3.
  • offload_param_nvme_path (str, mặc định là None) — Các tùy chọn khả dụng là /nvme|/local_nvme. Chỉ áp dụng với ZeRO Stage 3.
  • zero3_init_flag (bool, mặc định là None) — Cờ để chỉ định có lưu mô hình 16-bit hay không. Chỉ áp dụng với ZeRO Stage-3.
  • zero3_save_16bit_model (bool, mặc định là None) — Cờ chỉ định có lưu mô hình 16-bit hay không. Chỉ áp dụng với ZeRO Stage-3.
  • transformer_moe_cls_names (str, mặc định là None) — Danh sách các tên lớp lớp MoE của Transformers, phân tách bằng dấu phẩy (phân biệt hoa thường). Ví dụ, MixtralSparseMoeBlock, Qwen2MoeSparseMoeBlock, JetMoEAttention, JetMoEBlock, v.v.

Plugin này được sử dụng để tích hợp DeepSpeed.

deepspeed_config_process

< >

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

Xử lý cấu hình DeepSpeed với các giá trị từ kwargs.

select

< >

( _from_accelerator_state: bool = False )

Đặt HfDeepSpeedWeakref để sử dụng cấu hình deepspeed plugin hiện tại

lớp 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 )

Tham số

  • fsdp_version (int, mặc định là 1) — Phiên bản của FSDP cần sử dụng. Mặc định là 1. Nếu đặt thành 2, launcher sẽ kỳ vọng cấu hình đã được chuyển đổi sang định dạng FSDP2.
  • sharding_strategy (Union[str, torch.distributed.fsdp.ShardingStrategy], mặc định là 'FULL_SHARD') — Chiến lược sharding cần sử dụng. Phải là một str hoặc một instance của torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy. Đã bị ngừng khuyến khích, thay thế bằng reshard_after_forward.
  • reshard_after_forward (Union[str, torch.distributed.fsdp.ShardingStrategy, bool], mặc định là 'FULL_SHARD' cho fsdp_version=1 và True cho fsdp_version=2) — Chiến lược sharding cần sử dụng. Phải là một bool nếu fsdp_version được đặt thành 2, ngược lại phải là một str hoặc một instance của torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy.
  • backward_prefetch (Union[str, torch.distributed.fsdp.BackwardPrefetch], mặc định là 'NO_PREFETCH') — Chiến lược prefetch cho quá trình backward. Phải là một str hoặc một instance của torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch.
  • mixed_precision_policy (Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], mặc định là None) — Cấu hình để bật huấn luyện độ chính xác hỗn hợp với FullyShardedDataParallel. Nếu truyền vào một dict, nó phải có các khóa sau: param_dtype, reduce_dtype và buffer_dtype, có thể là một instance của torch.distributed.fsdp.MixedPrecisionPolicy nếu fsdp_version được đặt thành 2. Nếu truyền vào một str, nó phải là một trong các giá trị sau: fp8, fp16, bf16, fp32, và được dùng để đặt param_dtype, reduce_dtype và 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], mặc định là False) — Có nên offload tham số sang CPU hay không. Giá trị phải là bool hoặc một instance của torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload hoặc torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy nếu fsdp_version được đặt thành 2.
  • ignored_modules (Optional[Union[Iterable[torch.nn.Module], str]], mặc định là None) — Một danh sách các module cần bỏ qua khi bọc bằng FSDP. Khi truyền một chuỗi, các module sẽ được khớp theo tên bằng cách sử dụng regex fullmatch. Nếu fsdp_version được đặt thành 2, các module sẽ được chuyển đổi thành các tham số và được sử dụng.
  • state_dict_type (Union[str, torch.distributed.fsdp.StateDictType], mặc định là 'FULL_STATE_DICT') — Loại state dict cần sử dụng. Nếu là chuỗi, nó phải là một trong full_state_dict, local_state_dict hoặc sharded_state_dict.
  • state_dict_config (Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig], mặc định là None) — Cấu hình state dict cần sử dụng. Nếu không được truyền vào, giá trị này sẽ được xác định dựa trên state_dict_type.
  • optim_state_dict_config (Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], mặc định là None) — Cấu hình optim state dict cần sử dụng. Nếu không được truyền vào, giá trị này sẽ được xác định dựa trên state_dict_type.
  • limit_all_gathers (bool, mặc định là True) — Xác định việc FSDP có đồng bộ hóa rõ ràng luồng CPU để ngăn quá nhiều all-gathers đang chạy hay không. Giá trị bool này chỉ ảnh hưởng đến các chiến lược phân mảnh (sharded) có lịch trình all-gathers. Bật tùy chọn này có thể giúp giảm số lần thử lại (retries) của CUDA malloc.
  • use_orig_params (bool, mặc định là False) — Có sử dụng các tham số gốc cho optimizer hay không.
  • param_init_fn (Optional[Callable[[torch.nn.Module], None], mặc định là None) — Một Callable[torch.nn.Module] -> None quy định cách khởi tạo các module hiện đang trên thiết bị meta lên một thiết bị thực. Chỉ áp dụng khi sync_module_states là True. Mặc định là một lambda gọi to_empty trên module.
  • sync_module_states (bool, mặc định là False) — Liệu mỗi đơn vị FSDP được bọc riêng lẻ có nên phát trực tiếp (broadcast) các tham số module từ rank 0 để đảm bảo chúng giống nhau trên tất cả các rank sau khi khởi tạo hay không. Mặc định là False trừ khi cpu_ram_efficient_loading là True, khi đó nó sẽ được bật bắt buộc.
  • forward_prefetch (bool, mặc định là False) — Xác định việc FSDP có thực hiện prefetch (tải trước) cho phép all-gather tiếp theo trong khi thực hiện bước forward hay không. Chỉ sử dụng với đồ thị tĩnh (Static graphs).
  • activation_checkpointing (bool, mặc định là False) — Một kỹ thuật để giảm mức sử dụng bộ nhớ bằng cách xóa các activation của một số lớp nhất định và tính toán lại chúng trong quá trình truyền ngược (backward pass). Về cơ bản, kỹ thuật này đánh đổi thêm thời gian tính toán để đổi lấy việc giảm mức sử dụng bộ nhớ.
  • cpu_ram_efficient_loading (bool, mặc định là None) — Nếu là True, chỉ tiến trình đầu tiên tải checkpoint của model được huấn luyện trước, trong khi tất cả các tiến trình khác có trọng số rỗng. Chỉ áp dụng cho Transformers. Khi sử dụng tính năng này, sync_module_states cần được đặt là True.
  • transformer_cls_names_to_wrap (Optional[List[str]], mặc định là None) — Một danh sách tên lớp của các lớp transformer cần bọc. Chỉ áp dụng khi auto_wrap_policy là transformer_based_wrap.
  • min_num_params (Optional[int], mặc định là None) — Số lượng tham số tối thiểu mà một module phải có để được bọc. Chỉ áp dụng khi auto_wrap_policy là size_based_wrap.

Plugin này được sử dụng để bật song song dữ liệu phân mảnh hoàn toàn.

set_auto_wrap_policy

< >

( model )

Với model, tạo một auto_wrap_policy dựa trên chính sách được truyền vào và nếu chúng ta có thể sử dụng transformer_cls_to_wrap

set_mixed_precision

< >

( mixed_precisionbuffer_autocast = Falseoverride = False )

Đặt chính sách độ chính xác hỗn hợp cho FSDP

set_state_dict_type

< >

( state_dict_type = None )

Đặt cấu hình state dict dựa trên StateDictType.

validate_mixed_precision_policy

< >

( )

Kiểm tra chính sách độ chính xác hỗn hợp, được trừu tượng hóa để không đưa các lệnh import vào nếu không cần thiết.

lớp accelerate.utils.GradientAccumulationPlugin

< >

( num_steps: int = Noneadjust_scheduler: bool = Truesync_with_dataloader: bool = Truesync_each_batch: bool = False )

Tham số

  • num_steps (int) — Số bước để tích lũy gradient.
  • adjust_scheduler (bool, tùy chọn, mặc định là True) — Có điều chỉnh các bước của scheduler để tính đến số bước đang được tích lũy hay không. Nên đặt là True nếu scheduler đang sử dụng chưa được điều chỉnh cho việc tích lũy gradient.
  • sync_with_dataloader (bool, tùy chọn, mặc định là True) — Có đồng bộ hóa việc đặt gradient khi đến cuối dataloader hay không.
  • sync_each_batch (bool, tùy chọn) — Có đồng bộ hóa việc đặt gradient ở mỗi lô dữ liệu hay không. Đặt thành True có thể giảm yêu cầu về bộ nhớ khi sử dụng tích lũy gradient với huấn luyện phân tán, với cái giá là tốc độ.

Một plugin để cấu hình hành vi tích lũy gradient. Bạn chỉ có thể truyền một trong gradient_accumulation_plugin hoặc gradient_accumulation_steps cho Accelerator. Truyền cả hai sẽ gây ra lỗi.

Ví dụ:

from accelerate.utils import GradientAccumulationPlugin

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

class 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 = 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 )

Tham số

  • tp_degree (int, mặc định là None) — Độ song song tensor.
  • pp_degree (int, mặc định là None) — Độ song song hóa pipeline.
  • num_micro_batches (int, mặc định là None) — Số lượng micro-batch.
  • gradient_clipping (float, mặc định là None) — Giá trị cắt gradient dựa trên chuẩn L2 toàn cục (0 để tắt).
  • sequence_parallelism (bool, mặc định là None) — Bật song song hóa chuỗi (sequence parallelism).
  • recompute_activations (bool, mặc định là None) — Bật tính toán lại kích hoạt có chọn lọc.
  • use_distributed_optimizer (bool, mặc định là None) — Bật distributed optimizer.
  • pipeline_model_parallel_split_rank (int, mặc định là None) — Rank nơi encoder và decoder nên được tách ra.
  • num_layers_per_virtual_pipeline_stage (int, mặc định là None) — Số lượng lớp cho mỗi giai đoạn pipeline ảo.
  • is_train_batch_min (str, mặc định là True) — Nếu cả hai dataloader cho train & eval được chỉ định, tham số này sẽ quyết định micro_batch_size.
  • train_iters (int, mặc định là None) — Tổng số mẫu cần huấn luyện trên tất cả các lần chạy huấn luyện. Lưu ý rằng khi sử dụng MegatronLMDummyScheduler, bạn cần cung cấp train-iters hoặc train-samples.
  • train_samples (int, mặc định là None) — Tổng số mẫu để huấn luyện trên tất cả các lần chạy huấn luyện. Lưu ý rằng khi sử dụng MegatronLMDummyScheduler, bạn cần cung cấp train-iters hoặc train-samples.
  • weight_decay_incr_style (str, mặc định là 'constant') — Hàm tăng dần weight decay. choices=[“constant”, “linear”, “cosine”].
  • start_weight_decay (float, mặc định là None) — Hệ số suy giảm trọng số ban đầu cho quy tắc hóa L2.
  • end_weight_decay (float, mặc định là None) — Hệ số suy giảm trọng số cuối của quá trình chạy cho quy tắc hóa L2.
  • lr_decay_style (str, mặc định là 'linear') — Hàm suy giảm tốc độ học. choices=[‘constant’, ‘linear’, ‘cosine’].
  • lr_decay_iters (int, mặc định là None) — Số lần lặp cho việc suy giảm tốc độ học. Nếu là None, mặc định sẽ là train_iters.
  • lr_decay_samples (int, mặc định là None) — Số lượng mẫu cho việc suy giảm tốc độ học. Nếu là None, mặc định sẽ là train_samples.
  • lr_warmup_iters (int, mặc định là None) — Số lần lặp để tăng tuyến tính tốc độ học.
  • lr_warmup_samples (int, mặc định là None) — Số lượng mẫu để tăng tuyến tính tốc độ học.
  • lr_warmup_fraction (float, mặc định là None) — Tỷ lệ phần trăm của lr-warmup-(iters/samples) để làm nóng dần (warmup) tuyến tính tốc độ học (learning rate).
  • min_lr (float, mặc định là 0) — Giá trị tối thiểu cho tốc độ học. Trình lập lịch sẽ cắt các giá trị nằm dưới ngưỡng này.
  • consumed_samples (List, mặc định là None) — Số lượng mẫu đã được sử dụng theo cùng thứ tự với các dataloader trong lời gọi accelerator.prepare.
  • no_wd_decay_cond (Optional, mặc định là None) — Điều kiện để vô hiệu hóa weight decay.
  • scale_lr_cond (Optional, mặc định là None) — Điều kiện để điều chỉnh tốc độ học.
  • lr_mult (float, mặc định là 1.0) — Hệ số nhân tốc độ học.
  • megatron_dataset_flag (bool, mặc định là False) — Xác định xem định dạng của dataset có tuân theo định dạng Indexed/Cached/MemoryMapped của Megatron-LM hay không.
  • seq_length (int, mặc định là None) — Chiều dài tối đa của chuỗi để xử lý.
  • encoder_seq_length (int, mặc định là None) — Chiều dài tối đa của chuỗi để xử lý cho bộ mã hóa.
  • decoder_seq_length (int, mặc định là None) — Chiều dài tối đa của chuỗi để xử lý cho bộ giải mã.
  • tensorboard_dir (str, mặc định là None) — Đường dẫn để lưu các log tensorboard.
  • set_all_logging_options (bool, mặc định là False) — Có nên thiết lập tất cả các tùy chọn ghi log hay không.
  • eval_iters (int, mặc định là 100) — Số lần lặp chạy để đánh giá kiểm chứng/kiểm thử.
  • eval_interval (int, mặc định là 1000) — Khoảng thời gian giữa các lần chạy đánh giá trên tập kiểm tra.
  • return_logits (bool, mặc định là False) — Có nên trả về logits từ mô hình hay không.
  • custom_train_step_class (Optional, mặc định là None) — Lớp train step tùy chỉnh.
  • custom_train_step_kwargs (Optional, mặc định là None) — Các tham số kwargs tùy chỉnh cho bước huấn luyện.
  • custom_model_provider_function (Optional, mặc định là None) — Hàm cung cấp model tùy chỉnh.
  • custom_prepare_model_function (Optional, mặc định là None) — Hàm chuẩn bị mô hình tùy chỉnh.
  • custom_megatron_datasets_provider_function (Optional, mặc định là None) — Hàm cung cấp bộ dữ liệu train_valid_test megatron tùy chỉnh.
  • custom_get_batch_function (Optional, mặc định là None) — Hàm lấy batch tùy chỉnh.
  • custom_loss_function (Optional, mặc định là None) — Hàm loss tùy chỉnh.
  • other_megatron_args (Optional, mặc định là None) — Các đối số Megatron-LM khác. Vui lòng tham khảo Megatron-LM.

Plugin cho Megatron-LM để kích hoạt song song hóa tensor, pipeline, sequence và dữ liệu. Đồng thời kích hoạt tính toán lại kích hoạt có chọn lọc và các kernel hợp nhất được tối ưu hóa.

lớp accelerate.utils.TorchDynamoPlugin

< >

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

Tham số

  • backend (DynamoBackend, mặc định là None) — Một Dynamo backend hợp lệ. Xem https://pytorch.org/docs/stable/torch.compiler.html để biết thêm chi tiết.
  • mode (str, mặc định là None) — Các tùy chọn khả dụng là ‘default’, ‘reduce-overhead’ hoặc ‘max-autotune’.
  • fullgraph (bool, mặc định là None) — Liệu có được phép tách mô hình thành nhiều đồ thị con hay không.
  • dynamic (bool, mặc định là None) — Có sử dụng hình dạng động (dynamic shape) cho việc theo dõi (tracing) hay không.
  • options (Any, mặc định là None) — Một từ điển các tùy chọn để truyền cho backend.
  • disable (bool, mặc định là False) — Biến torch.compile() thành một thao tác không làm gì (no-op) để kiểm thử
  • use_regional_compilation (bool, mặc định là None) — Sử dụng tham số này để giảm thời gian biên dịch khởi động lạnh của torch.compile() bằng cách nhắm vào các khối lặp lại của cùng một lớp và biên dịch chúng tuần tự để tận dụng bộ nhớ đệm của trình biên dịch. Ví dụ, trong GPT2LMHeadModel, khối/lớp lặp lại là GPT2Block, và có thể truy cập qua model.transformer.h[0]. Phần còn lại của mô hình (ví dụ model.lm_head) được biên dịch riêng biệt.

Plugin này được sử dụng để biên dịch một mô hình với PyTorch 2.0

Cấu hình

Đây là các lớp có thể được cấu hình và truyền qua đến tích hợp phù hợp

lớp 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 = Nonekeep_in_fp32_modules: list = None )

Tham số

  • load_in_8bit (bool, mặc định là False) — Bật lượng tử hóa 8bit.
  • llm_int8_threshold (float, mặc định là 6.0) — Giá trị của ngưỡng outliner. Chỉ có liên quan khi load_in_8bit=True.
  • load_in_4bit (bool, mặc định là False) — Bật lượng tử hóa 4bit.
  • bnb_4bit_quant_type (str, mặc định là fp4) — Đặt kiểu dữ liệu lượng tử hóa trong các lớp bnb.nn.Linear4Bit. Các tùy chọn là {‘fp4’,‘np4’}.
  • bnb_4bit_use_double_quant (bool, mặc định là False) — Bật lượng tử hóa lồng nhau, trong đó các hằng số lượng tử hóa từ lần lượng tử hóa đầu tiên được lượng tử hóa lại.
  • bnb_4bit_compute_dtype (bool, mặc định là fp16) — Tham số này đặt kiểu tính toán, có thể khác với kiểu dữ liệu đầu vào. Ví dụ, đầu vào có thể là fp32, nhưng phép tính có thể được đặt thành bf16 để tăng tốc. Các tùy chọn là {‘fp32’,‘fp16’,‘bf16’}.
  • torch_dtype (torch.dtype, mặc định là None) — Tham số này đặt dtype cho các lớp còn lại không bị lượng tử hóa. Thư viện bitsandbytes gợi ý đặt giá trị thành torch.float16 cho mô hình 8 bit và sử dụng cùng dtype với dtype tính toán cho mô hình 4 bit.
  • skip_modules (List[str], mặc định là None) — Một danh sách rõ ràng các module mà chúng ta không lượng tử hóa. dtype của các module này sẽ là torch_dtype.
  • keep_in_fp32_modules (List, mặc định là None) — Một danh sách rõ ràng các module mà chúng ta không lượng tử hóa. Chúng ta giữ chúng ở dạng torch.float32.

Một plugin để bật lượng tử hóa 4 bit và 8 bit của BitsAndBytes

lớp 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 )

Tham số

  • split_batches (bool, mặc định là False) — Xác định xem accelerator có nên chia các batch do dataloaders tạo ra giữa các thiết bị hay không. Nếu True, kích thước batch thực tế được sử dụng sẽ giống nhau trên mọi loại tiến trình phân tán, nhưng nó phải là bội số nguyên của num_processes mà bạn đang sử dụng. Nếu False, kích thước batch thực tế được sử dụng sẽ là giá trị đã đặt trong script của bạn nhân với số lượng tiến trình.
  • dispatch_batches (bool, mặc định là None) — Nếu được đặt thành True, dataloader được chuẩn bị bởi Accelerator chỉ được lặp qua trên tiến trình chính, sau đó các batch sẽ được chia nhỏ và phát sóng đến từng tiến trình. Giá trị mặc định sẽ là True đối với DataLoader có bộ dữ liệu nền là IterableDataset, còn lại là False.
  • even_batches (bool, mặc định là True) — Nếu được đặt thành True, trong các trường hợp tổng kích thước batch trên tất cả các tiến trình không chia hết chính xác cho bộ dữ liệu, các mẫu ở đầu bộ dữ liệu sẽ được nhân bản để batch có thể được chia đều cho tất cả các worker.
  • use_seedable_sampler (bool, mặc định là False) — Có sử dụng bộ lấy mẫu ngẫu nhiên hoàn toàn có thể đặt hạt giống (data_loader.SeedableRandomSampler) hay không. Đảm bảo kết quả huấn luyện hoàn toàn có thể tái lập bằng cách sử dụng kỹ thuật lấy mẫu khác. Mặc dù kết quả giữa các lần đặt hạt giống có thể khác nhau, nhưng trung bình sự khác biệt là không đáng kể khi sử dụng nhiều hạt giống khác nhau để so sánh. Nên chạy cùng với set_seed() để đạt kết quả tốt nhất.
  • data_seed (int, mặc định là None) — Hạt giống (seed) được sử dụng cho bộ tạo (generator) bên dưới khi dùng use_seedable_sampler. Nếu là None, bộ tạo sẽ sử dụng hạt giống mặc định hiện tại từ torch.
  • non_blocking (bool, mặc định là False) — Nếu được đặt thành True, dataloader được chuẩn bị bởi Accelerator sẽ sử dụng các thao tác chuyển dữ liệu từ host sang thiết bị không chặn (non-blocking), cho phép chồng chéo tốt hơn giữa việc truyền thông của dataloader và tính toán. Khuyến nghị rằng dataloader đã được chuẩn bị nên có pin_memory được đặt thành True để hoạt động đúng.
  • use_stateful_dataloader (bool, mặc định là False) — Nếu đặt thành True, dataloader được chuẩn bị bởi Accelerator sẽ được hỗ trợ bởi torchdata.StatefulDataLoader. Điều này yêu cầu phải cài đặt torchdata phiên bản 0.8.0 trở lên, hỗ trợ StatefulDataLoader.

Cấu hình cho các mục liên quan đến dataloader khi gọi accelerator.prepare.

lớp accelerate.utils.ProjectConfiguration

< >

( project_dir: str = Nonelogging_dir: str = Noneautomatic_checkpoint_naming: bool = Falsetotal_limit: int = Noneiteration: int = 0save_on_each_node: bool = False )

Tham số

  • project_dir (str, mặc định là None) — Đường dẫn đến thư mục để lưu trữ dữ liệu.
  • logging_dir (str, mặc định là None) — Đường dẫn đến thư mục để lưu trữ nhật ký của các trình ghi nhật ký tương thích cục bộ. Nếu là None, mặc định là project_dir.
  • automatic_checkpoint_naming (bool, mặc định là False) — Xác định xem các trạng thái được lưu có nên được đặt tên tự động theo trình tự lặp lại hay không.
  • total_limit (int, mặc định là None) — Số lượng tối đa của các trạng thái đã lưu tổng cộng cần giữ lại.
  • iteration (int, mặc định là 0) — Lần lặp lưu hiện tại.
  • save_on_each_node (bool, mặc định là False) — Khi thực hiện huấn luyện phân tán đa nút, có nên lưu các mô hình và checkpoint trên mỗi nút hay chỉ trên nút chính.

Cấu hình cho đối tượng Accelerator dựa trên nhu cầu của dự án bên trong.

set_directories

< >

( project_dir: str | None = None )

Đặt self.project_dir và self.logging_dir thành các giá trị phù hợp.

Biến môi trường

Đây là các biến môi trường có thể được bật cho các trường hợp sử dụng khác nhau

  • ACCELERATE_DEBUG_MODE (str): Xác định có chạy accelerate ở chế độ gỡ lỗi hay không. Thông tin chi tiết có tại đây.

Xử lý và Thao tác Dữ liệu

Các thao tác này bao gồm các thao tác dữ liệu mô phỏng các op torch tương tự nhưng có thể được sử dụng trên các tiến trình phân tán.

accelerate.utils.broadcast

< >

( tensorfrom_process: int = 0 )

Tham số

  • tensor (danh sách/bộ/dictionary lồng nhau của torch.Tensor) — Dữ liệu cần thu thập.
  • from_process (int, tuỳ chọn, mặc định là 0) — Quy trình để gửi dữ liệu

Phát sóng đệ quy tensor trong danh sách/bộ/bộ từ điển lồng nhau của tensor đến tất cả các thiết bị.

accelerate.utils.broadcast_object_list

< >

( object_listfrom_process: int = 0 )

Tham số

  • object_list (list of picklable objects) — Danh sách các đối tượng cần phát trực tiếp (broadcast). Danh sách này sẽ bị thay đổi tại chỗ (inplace).
  • from_process (int, tuỳ chọn, mặc định là 0) — Quy trình để gửi dữ liệu.

Phát trực tiếp một danh sách các đối tượng có thể picklable từ một tiến trình sang các tiến trình khác.

accelerate.utils.concatenate

< >

( datadim = 0 )

Tham số

  • data (danh sách/bộ/bộ từ điển lồng nhau chứa các danh sách tensor torch.Tensor) — Dữ liệu cần nối.
  • dim (int, tuỳ chọn, mặc định là 0) — Chiều để ghép nối.

Nối đệ quy các tensor trong một danh sách/bộ/bộ từ điển lồng nhau chứa các danh sách tensor có cùng hình dạng. Nếu chỉ có một lô dữ liệu duy nhất, nó sẽ được trả về nguyên vẹn.

accelerate.utils.convert_outputs_to_fp32

< >

( model_forward )

accelerate.utils.convert_to_fp32

< >

( tensor )

Tham số

  • tensor (danh sách/bộ/dictionary lồng nhau của torch.Tensor) — Dữ liệu cần chuyển đổi từ FP16/BF16 sang FP32.

Chuyển đệ quy các phần tử trong danh sách/bộ/đệ quy của các tensor ở độ chính xác FP16/BF16 sang FP32.

accelerate.utils.gather

< >

( tensor )

Tham số

  • tensor (danh sách/bộ/dictionary lồng nhau của torch.Tensor) — Dữ liệu cần thu thập.

Thu thập đệ quy tensor trong một danh sách/bộ/bộ từ điển lồng nhau của các tensor từ tất cả các thiết bị.

accelerate.utils.gather_object

< >

( object: Any )

Tham số

  • object (danh sách/bộ/dictionary lồng nhau của các object có thể picklable) — Dữ liệu cần thu thập.

Thu thập đệ quy đối tượng trong danh sách/bộ/bộ từ điển lồng nhau của các đối tượng từ tất cả các thiết bị.

accelerate.utils.get_grad_scaler

< >

( distributed_type: DistributedType = None**kwargs )

Tham số

  • distributed_type (DistributedType, tùy chọn, mặc định là None) — Loại môi trường phân tán.
  • kwargs — Các đối số bổ sung cho bộ khởi tạo GradScaler được sử dụng.

Một hàm trợ giúp chung sẽ khởi tạo đúng triển khai GradScaler dựa trên môi trường và trả về nó.

accelerate.utils.get_mixed_precision_context_manager

< >

( native_amp: bool = Falseautocast_kwargs: AutocastKwargs = None )

Tham số

  • native_amp (bool, tùy chọn, mặc định là False) — Xác định xem độ chính xác hỗn hợp có thực sự được bật hay không.

Trả về một trình quản lý ngữ cảnh cho việc tự động chuyển đổi độ chính xác hỗn hợp

accelerate.utils.listify

< >

( data )

Tham số

  • data (nested list/tuple/dictionary of torch.Tensor) — Dữ liệu để chuyển đổi thành các số thông thường.

Tìm đệ quy các tensor trong danh sách/bộ/bộ từ điển lồng nhau và chuyển đổi chúng thành danh sách các số.

accelerate.utils.pad_across_processes

< >

( tensordim = 0pad_index = 0pad_first = False )

Tham số

  • tensor (danh sách/bộ/dictionary lồng nhau của torch.Tensor) — Dữ liệu cần thu thập.
  • dim (int, tùy chọn, mặc định là 0) — Chiều cần đệm.
  • pad_index (int, tùy chọn, mặc định là 0) — Giá trị dùng để đệm.
  • pad_first (bool, tùy chọn, mặc định là False) — Có nên đệm ở đầu hay ở cuối không.

Đệm đệ quy các tensor trong danh sách/bộ/bộ từ điển lồng nhau của các tensor từ tất cả các thiết bị để chúng có cùng kích thước, nhằm có thể thu thập chúng một cách an toàn.

accelerate.utils.recursively_apply

< >

( funcdata*argstest_type = <function is_torch_tensor at 0x7fe7449bfed0>error_on_other_type = False**kwargs )

Tham số

  • func (callable) — Hàm cần áp dụng đệ quy.
  • data (danh sách/bộ/dictionary lồng nhau của các đối tượng được chấp nhận bởi test_type) — Dữ liệu để áp dụng func
  • *args — Các đối số vị trí sẽ được truyền vào func khi áp dụng trên dữ liệu đã được giải nén.
  • test_type (Callable[[Any], bool], tùy chọn, mặc định là is_torch_tensor) — Biểu thức điều kiện quyết định xem có nên áp dụng func lên một đối tượng lá cụ thể hay không.
  • error_on_other_type (bool, tùy chọn, mặc định là False) — Có nên trả về lỗi hay không nếu sau khi giải nén data, chúng ta nhận được một đối tượng mà test_type trả về False. Nếu False, hàm sẽ giữ nguyên các đối tượng như vậy.
  • **kwargs (các tham số từ khóa bổ sung, tùy chọn) — Các tham số từ khóa sẽ được truyền vào func khi áp dụng lên dữ liệu đã được giải nén.

Áp dụng đệ quy một hàm lên một cấu trúc dữ liệu là danh sách/bộ/bộ từ điển lồng nhau của một kiểu cơ sở cho trước.

accelerate.utils.reduce

< >

( tensorreduction = 'mean'scale = 1.0 )

Tham số

  • tensor (danh sách/bộ/dictionary lồng nhau của torch.Tensor) — Dữ liệu cần giảm.
  • reduction (str, không bắt buộc, mặc định là "mean") — Phương pháp giảm. Có thể là “mean”, “sum”, “max” hoặc “none”
  • scale (float, tùy chọn) — Giá trị tỷ lệ mặc định được áp dụng sau khi thực hiện reduce, chỉ hợp lệ trên XLA.

Giảm đệ quy các tensor trong một danh sách/bộ/bộ từ điển lồng nhau chứa các danh sách tensor trên tất cả các tiến trình bằng cách lấy trung bình của một thao tác cho trước.

accelerate.utils.send_to_device

< >

( tensordevicenon_blocking = Falseskip_keys = None )

Tham số

  • tensor (danh sách/bộ/dictionary lồng nhau của torch.Tensor) — Dữ liệu cần gửi đến một thiết bị nhất định.
  • device (torch.device) — Thiết bị để gửi dữ liệu đến.
  • non_blocking (bool, tùy chọn, mặc định là False) — Nếu True, quá trình chuyển đến thiết bị sẽ được thực hiện bất đồng bộ, cho phép chồng chéo việc di chuyển dữ liệu với tính toán. Chỉ có hiệu lực khi thiết bị hỗ trợ (ví dụ: CUDA).
  • skip_keys (str hoặc List[str], tùy chọn) — Một khóa hoặc danh sách các khóa trong từ điển tensor mà giá trị của chúng không nên được gửi đến device đã cho. Các mục có những khóa này sẽ được giữ lại trên thiết bị ban đầu của chúng.

Gửi đệ quy các phần tử trong một danh sách/bộ/bộ từ điển lồng nhau của các tensor đến một thiết bị được chỉ định.

accelerate.utils.slice_tensors

< >

( datatensor_sliceprocess_index = Nonenum_processes = None )

Tham số

  • data (danh sách/bộ/bộ từ điển lồng nhau của torch.Tensor) — Dữ liệu cần cắt.
  • tensor_slice (slice) — Phần lát cần lấy.

Lấy một lát cắt đệ quy trong danh sách/bộ/bộ từ điển lồng nhau của các tensor.

Kiểm tra môi trường

Các chức năng này kiểm tra trạng thái của môi trường làm việc hiện tại, bao gồm thông tin về chính hệ điều hành, những gì nó có thể hỗ trợ và các phụ thuộc cụ thể đã được cài đặt hay chưa.

accelerate.utils.is_bf16_available

< >

( ignore_tpu = False )

Kiểm tra xem bf16 có được hỗ trợ hay không, tùy chọn bỏ qua TPU

accelerate.utils.is_mps_available

< >

( min_version = '1.12' )

Kiểm tra xem thiết bị MPS có khả dụng hay không. Phiên bản tối thiểu yêu cầu là 1.12.

accelerate.utils.is_npu_available

( check_device = False )

Kiểm tra xem torch_npu đã được cài đặt hay chưa và có thể kiểm tra xem môi trường có NPU hay không

accelerate.utils.is_torch_version

< >

( operation: strversion: str )

Tham số

  • operation (str) — Một chuỗi đại diện cho một toán tử, chẳng hạn như ">" hoặc "<="
  • version (str) — Một chuỗi phiên bản của PyTorch

So sánh phiên bản PyTorch hiện tại với một tham chiếu đã cho bằng một phép toán.

accelerate.utils.is_torch_xla_available

( check_is_tpu = Falsecheck_is_gpu = False )

Kiểm tra xem torch_xla có khả dụng hay không. Để huấn luyện một tác vụ pytorch thuần trong môi trường đã cài đặt torch xla, hãy đặt USE_TORCH_XLA thành false.

accelerate.utils.is_xpu_available

( check_device = False )

Kiểm tra xem tăng tốc XPU có khả dụng thông qua PyTorch chuẩn (>=2.7) và có thể kiểm tra xem có XPU trong môi trường hay không

Thao tác Môi trường

accelerate.utils.patch_environment

< >

( **kwargs )

Một trình quản lý ngữ cảnh sẽ thêm mỗi đối số từ khóa được truyền vào os.environ và xóa chúng khi thoát.

Sẽ chuyển các giá trị trong kwargs thành chuỗi và viết hoa tất cả các khóa.

Ví dụ:

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

< >

( )

Một trình quản lý ngữ cảnh sẽ tạm thời xóa các biến môi trường.

Khi ngữ cảnh này kết thúc, các biến môi trường trước đó sẽ được khôi phục.

Ví dụ:

>>> 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' )

Tham số

  • mixed_precision (str, tùy chọn, mặc định là “no”) — Mixed Precision cần sử dụng. Phải là một trong “no”, “fp16” hoặc “bf16”
  • save_location (str, tùy chọn, mặc định là default_json_config_file) — Vị trí lưu tùy chỉnh tùy chọn. Cần được truyền vào --config_file khi sử dụng accelerate launch. Vị trí mặc định nằm trong thư mục cache của huggingface (~/.cache/huggingface) nhưng có thể được ghi đè bằng cách đặt biến môi trường HF_HOME, sau đó là accelerate/default_config.yaml.

Tạo và lưu cấu hình cụm cơ bản để sử dụng trên máy cục bộ, có thể có nhiều GPU. Đồng thời sẽ thiết lập CPU nếu đó là máy chỉ có CPU.

Khi thiết lập 🤗 Accelerate lần đầu tiên, thay vì chạy accelerate config, [~utils.write_basic_config] có thể được sử dụng như một phương án thay thế để cấu hình nhanh.

accelerate.utils.set_numa_affinity

( local_process_index: intverbose: bool | None = None )

Tham số

  • local_process_index (int) — Chỉ số của tiến trình hiện tại trên máy chủ hiện tại.
  • verbose (bool, tùy chọn) — Có in ra gán lõi CPU mới cho từng tiến trình hay không. Nếu ACCELERATE_DEBUG_MODE được bật, mặc định là True.

Gán tiến trình hiện tại cho một nút NUMA cụ thể. Hiệu quả nhất khi mỗi nút có ít nhất 2 cpu.

Kết quả này được lưu đệm giữa các lần gọi. Nếu bạn muốn ghi đè lên nó, vui lòng sử dụng accelerate.utils.environment.override_numa_afifnity.

accelerate.utils.environment.override_numa_affinity

< >

( local_process_index: intverbose: bool | None = None )

Tham số

  • local_process_index (int) — Chỉ số của tiến trình hiện tại trên máy chủ hiện tại.
  • verbose (bool, tùy chọn) — Có ghi log việc phân bổ cho từng CPU hay không. Nếu ACCELERATE_DEBUG_MODE được bật, giá trị mặc định sẽ là True.

Ghi đè bất kỳ NUMA affinity nào được đặt cho tiến trình hiện tại. Thao tác này rất tốn kém và yêu cầu tính toán lại affinity cần đặt, lý tưởng nhất là bạn nên sử dụng utils.environment.set_numa_affinity thay thế.

accelerate.utils.purge_accelerate_environment

< >

( func_or_cls )

Decorator để dọn dẹp các biến môi trường của accelerate được đặt bởi lớp hoặc hàm được trang trí.

Trong một số trường hợp, việc gọi một số class hoặc function nhất định có thể dẫn đến việc các biến môi trường của accelerate được đặt và không được dọn dẹp sau đó. Ví dụ, khi gọi:

TrainingArguments(fp16=True, …)

Biến môi trường sau sẽ được đặt:

ACCELERATE_MIXED_PRECISION=fp16

Điều này có thể ảnh hưởng đến các đoạn mã tiếp theo, vì biến môi trường có độ ưu tiên cao hơn so với TrainingArguments(fp16=False). Điều này đặc biệt quan trọng trong kiểm thử đơn vị, nơi chúng ta muốn tránh việc các bài kiểm thử riêng lẻ gây ra các tác dụng phụ lẫn nhau. Trang trí hàm kiểm thử đơn vị hoặc toàn bộ lớp bằng bộ trang trí này để đảm bảo rằng sau mỗi bài kiểm thử, các biến môi trường được dọn dẹp. Cách này hoạt động cho cả unittest.TestCase và các lớp thông thường (pytest); nó cũng hoạt động khi trang trí lớp cha.

Bộ nhớ

accelerate.find_executable_batch_size

< >

( function: callable | None = Nonestarting_batch_size: int = 128reduce_batch_size_fn: callable | None = None )

Tham số

  • function (callable, optional) — Một hàm để bọc
  • starting_batch_size (int, tùy chọn) — Kích thước batch để thử vừa vào bộ nhớ
  • reduce_batch_size_fn (callable, tùy chọn) — Một hàm để xác định kích thước batch mới sau một lỗi hết bộ nhớ. Nếu không được cung cấp, kích thước batch sẽ được nhân với 0.9 sau mỗi lần thất bại. Hàm này không nhận đối số và phải trả về kích thước batch mới (đã giảm) dưới dạng int.

Một decorator cơ bản sẽ cố gắng thực thi function. Nếu thất bại do các ngoại lệ liên quan đến hết bộ nhớ hoặc CUDNN, kích thước lô sẽ được nhân với 0.9 và được truyền vào function

function phải nhận tham số batch_size làm đối số đầu tiên.

Ví dụ:

>>> 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)

Mô hình hóa

Các tiện ích này liên quan đến việc tương tác với các mô hình PyTorch

accelerate.utils.calculate_maximum_sizes

< >

( model: Module )

Tính toán kích thước tổng của mô hình và lớp lớn nhất của nó

accelerate.utils.compute_module_sizes

< >

( model: Moduledtype: str | torch.device | None = Nonespecial_dtypes: dict[str, str | torch.device] | None = Nonebuffers_only: bool = False )

Tính kích thước của từng mô-đun con của một mô hình cho trước.

accelerate.utils.extract_model_from_parallel

< >

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

Tham số

  • model (torch.nn.Module) — Mô hình cần trích xuất.
  • keep_fp32_wrapper (bool, tuỳ chọn) — Có nên gỡ bỏ các hook độ chính xác hỗn hợp khỏi mô hình hay không.
  • keep_torch_compile (bool, tùy chọn) — Có nên gỡ bỏ lớp bọc của mô hình đã biên dịch hay không.
  • recursive (bool, tuỳ chọn, mặc định là False) — Có nên đệ quy trích xuất tất cả các trường hợp của module.module từ model cũng như mở bọc đệ quy các lớp con trực thuộc, thay vì chỉ các container phân phối ở cấp cao nhất hay không.

Trả về

torch.nn.Module

Mô hình đã được trích xuất.

Trích xuất một mô hình từ các container phân tán của nó.

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 )

Tham số

  • model (torch.nn.Module) — Mô hình cần phân tích.
  • max_memory (Dict, tùy chọn) — Một từ điển ánh xạ định danh thiết bị tới bộ nhớ tối đa. Nếu không được đặt, giá trị mặc định sẽ là bộ nhớ tối đa khả dụng. Ví dụ: max_memory={0: "1GB"}.
  • no_split_module_classes (List[str], tùy chọn) — Một danh sách tên lớp lớp (layer class) không bao giờ được phép tách ra giữa các thiết bị (ví dụ bất kỳ lớp nào có kết nối dư (residual connection)).
  • dtype (str hoặc torch.dtype, tùy chọn) — Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi tải.
  • special_dtypes (Dict[str, Union[str, torch.device]], tùy chọn) — Nếu được cung cấp, các dtype đặc biệt cần xem xét cho một số trọng số cụ thể (sẽ ghi đè dtype được dùng làm mặc định cho tất cả các trọng số).
  • low_zero (bool, tùy chọn) — Giảm thiểu số lượng trọng số trên GPU 0, rất tiện lợi khi GPU này được dùng cho các thao tác khác (chẳng hạn như hàm generate của Transformers).

Tính toán từ điển max_memory cho infer_auto_device_map() để cân bằng việc sử dụng mỗi GPU khả dụng.

Toàn bộ phép tính được thực hiện bằng cách phân tích kích thước và dtype của các tham số mô hình. Do đó, mô hình có thể nằm trên thiết bị meta (như khi được khởi tạo bên trong trình quản lý ngữ cảnh init_empty_weights).

accelerate.utils.get_max_layer_size

< >

( modules: listmodule_sizes: dictno_split_module_classes: list ) → Tuple[int, List[str]]

Tham số

  • modules (List[Tuple[str, torch.nn.Module]]) — Danh sách các module có tên mà chúng ta muốn xác định kích thước lớp tối đa.
  • module_sizes (Dict[str, int]) — Một từ điển ánh xạ mỗi tên lớp đến kích thước của nó (được tạo bởi compute_module_sizes).
  • no_split_module_classes (List[str]) — Danh sách tên lớp cho các lớp mà chúng ta không muốn tách.

Trả về

Tuple[int, List[str]]

Kích thước tối đa của một lớp kèm theo danh sách tên các lớp đạt được kích thước tối đa đó.

Hàm tiện ích sẽ quét một danh sách các module có tên và trả về kích thước tối đa được sử dụng bởi một lớp đầy đủ. Định nghĩa của một lớp là:

  • một module không có con trực tiếp (chỉ có tham số và bộ đệm)
  • một module có tên lớp nằm trong danh sách 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 )

Tham số

  • model (torch.nn.Module) — Mô hình cần phân tích.
  • max_memory (Dict, tùy chọn) — Một từ điển ánh xạ định danh thiết bị tới bộ nhớ tối đa. Nếu không được đặt, giá trị mặc định sẽ là bộ nhớ tối đa khả dụng. Ví dụ: max_memory={0: "1GB"}.
  • no_split_module_classes (List[str], tùy chọn) — Một danh sách tên lớp lớp (layer class) không bao giờ được phép tách ra giữa các thiết bị (ví dụ bất kỳ lớp nào có kết nối dư (residual connection)).
  • dtype (str hoặc torch.dtype, tùy chọn) — Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi tải.
  • special_dtypes (Dict[str, Union[str, torch.device]], tùy chọn) — Nếu được cung cấp, các dtype đặc biệt cần xem xét cho một số trọng số cụ thể (sẽ ghi đè dtype được dùng làm mặc định cho tất cả các trọng số).
  • verbose (bool, tùy chọn, mặc định là False) — Có cung cấp các câu lệnh gỡ lỗi khi hàm xây dựng device_map hay không.
  • clean_result (bool, tùy chọn, mặc định là True) — Làm sạch device_map kết quả bằng cách nhóm tất cả các submodule chạy trên cùng một thiết bị lại với nhau.
  • offload_buffers (bool, tùy chọn, mặc định là False) — Trong các lớp được offload lên CPU hoặc ổ cứng, có offload các buffer cùng với các tham số hay không.
  • fallback_allocation (bool, tùy chọn, mặc định là False) — Khi phân bổ thông thường thất bại, hãy thử phân bổ một module phù hợp với giới hạn kích thước bằng BFS.

Tính toán bản đồ thiết bị cho một mô hình đã cho, ưu tiên sử dụng GPU, sau đó offload lên CPU và cuối cùng offload xuống đĩa, sao cho:

  • chúng ta không vượt quá bộ nhớ khả dụng của bất kỳ GPU nào.
  • nếu cần offload sang CPU, luôn còn chỗ trống trên GPU 0 để đưa lại lớp đã được offload sang CPU có kích thước lớn nhất.
  • nếu cần offload sang CPU, chúng ta sẽ không vượt quá dung lượng RAM khả dụng trên CPU.
  • nếu cần offload ra đĩa, luôn còn chỗ trống trên CPU để đưa trở lại lớp có kích thước lớn nhất đã được offload ra đĩa.

Toàn bộ phép tính được thực hiện bằng cách phân tích kích thước và dtype của các tham số mô hình. Do đó, mô hình có thể nằm trên thiết bị meta (như khi được khởi tạo bên trong trình quản lý ngữ cảnh 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 )

Tham số

  • model (torch.nn.Module) — Mô hình mà chúng ta muốn nạp checkpoint vào.
  • checkpoint (str hoặc os.PathLike) — Checkpoint thư mục cần tải. Nó có thể là:
    • đường dẫn đến tệp chứa toàn bộ state dict của mô hình
    • đường dẫn đến tệp .json chứa chỉ mục của checkpoint phân mảnh
    • đường dẫn đến một thư mục chứa tệp .index.json duy nhất và các shard của checkpoint.
    • đường dẫn đến một thư mục chứa tệp pytorch_model.bin hoặc tệp model.safetensors duy nhất.
  • device_map (Dict[str, Union[int, str, torch.device]], tùy chọn) — Một bản đồ chỉ định vị trí của từng submodule. Không cần chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một thiết bị.
  • offload_folder (str hoặc os.PathLike, tùy chọn) — Nếu device_map chứa bất kỳ giá trị nào là "disk", đây là thư mục nơi chúng ta sẽ offload trọng số.
  • dtype (str hoặc torch.dtype, tùy chọn) — Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi tải.
  • offload_state_dict (bool, tùy chọn, mặc định là False) — Nếu True, sẽ tạm thời offload state dict CPU xuống ổ cứng để tránh hết RAM CPU nếu trọng số của state dict CPU + shard lớn nhất không vừa.
  • offload_buffers (bool, tùy chọn, mặc định là False) — Có bao gồm các buffer trong các trọng số được offload xuống đĩa hay không.
  • keep_in_fp32_modules(List[str], tuỳ chọn) — Danh sách các module mà chúng ta giữ ở kiểu dữ liệu torch.float32.
  • offload_8bit_bnb (bool, tùy chọn) — Có bật offload các module 8-bit lên cpu/disk hay không.
  • strict (bool, tùy chọn, mặc định là False) — Có nên thực thi nghiêm ngặt việc các khóa trong state_dict của checkpoint khớp với các khóa của state_dict của mô hình hay không.
  • full_state_dict (bool, tùy chọn, mặc định là True) — nếu được đặt thành True, tất cả các tensor trong state_dict đã tải sẽ được gom lại. Không có ShardedTensor và DTensor nào trong state_dict đã tải.
  • broadcast_from_rank0 (False, tùy chọn, mặc định là False) — khi tùy chọn này là True, một nhóm tiến trình phân tán ProcessGroup phải được khởi tạo. rank0 sẽ nhận state_dict đầy đủ và phát trực tiếp (broadcast) các tensor trong state_dict lần lượt đến các rank khác. Các rank khác sẽ nhận các tensor và chia nhỏ (shard, nếu áp dụng) theo các shard cục bộ trong mô hình.

Tải một checkpoint (có thể được chia mảnh) bên trong một model, đồng thời có thể gửi các trọng số đến một thiết bị đã cho trong khi chúng được tải.

Sau khi được nạp trên các thiết bị, bạn vẫn cần gọi dispatch_model() trên mô hình của mình để nó có thể chạy. Để nhóm việc nạp checkpoint và dispatch vào một lần gọi duy nhất, hãy sử dụng load_checkpoint_and_dispatch().

accelerate.utils.load_offloaded_weights

< >

( modelindexoffload_folder )

Tham số

  • model (torch.nn.Module) — Mô hình để nạp trọng số vào.
  • index (dict) — Một từ điển chứa tên tham số và các siêu dữ liệu của nó cho từng tham số đã được offload khỏi mô hình.
  • offload_folder (str) — Thư mục nơi các trọng số bị offload được lưu trữ.

Tải trọng số từ thư mục offload vào mô hình.

accelerate.utils.load_state_dict

< >

( checkpoint_filedevice_map = None )

Tham số

  • checkpoint_file (str) — Đường dẫn đến checkpoint cần tải.
  • device_map (Dict[str, Union[int, str, torch.device]], tùy chọn) — Một bản đồ chỉ định vị trí của từng submodule. Không cần chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một thiết bị.

Tải checkpoint từ một tệp được chỉ định. Nếu checkpoint ở định dạng safetensors và một device map được truyền vào, các trọng số có thể được tải nhanh trực tiếp trên GPU.

accelerate.utils.offload_state_dict

< >

( save_dir: str | os.PathLikestate_dict: dict )

Tham số

  • save_dir (str hoặc os.PathLike) — Thư mục để offload state dict.
  • state_dict (Dict[str, torch.Tensor]) — Từ điển các tensor cần offload.

Tải xuống một state dict vào một thư mục đã cho.

accelerate.utils.retie_parameters

< >

( modeltied_params )

Tham số

  • model (torch.nn.Module) — Mô hình mà bạn muốn gắn lại các tham số.
  • tied_params (List[List[str]]) — Bản ánh xạ từ tên tham số sang tên tham số liên kết, được lấy từ find_tied_parameters.

Thiết lập lại các tham số bị ràng buộc trong một mô hình đã cho nếu liên kết bị hỏng (ví dụ khi thêm các 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 )

Tham số

  • module (torch.nn.Module) — Module chứa tensor mà chúng ta muốn di chuyển.
  • tensor_name (str) — Tên đầy đủ của tham số/buffer.
  • device (int, str hoặc torch.device) — Thiết bị để đặt tensor.
  • value (torch.Tensor, tùy chọn) — Giá trị của tensor (hữu ích khi chuyển từ thiết bị meta sang bất kỳ thiết bị nào khác).
  • dtype (torch.dtype, tùy chọn) — Nếu được truyền, giá trị của tham số sẽ được chuyển đổi sang dtype này. Nếu không, value sẽ được chuyển đổi sang dtype của tham số hiện có trong mô hình.
  • fp16_statistics (torch.HalfTensor, tùy chọn) — Danh sách các thống kê fp16 để thiết lập cho module, được sử dụng cho việc xuất mô hình 8 bit.
  • tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], optional, mặc định là None) — Một bản đồ ánh xạ các con trỏ dữ liệu hiện tại tới các từ điển ánh xạ thiết bị tới các trọng số liên kết đã được điều phối. Đối với một thiết bị thực thi nhất định, tham số này hữu ích để tái sử dụng con trỏ khả dụng đầu tiên của một trọng số dùng chung trên thiết bị đó cho tất cả các trường hợp khác, thay vì sao chép bộ nhớ.
  • non_blocking (bool, tùy chọn, mặc định là False) — Nếu True, việc chuyển thiết bị sẽ diễn ra bất đồng bộ so với host, nếu có thể.
  • clear_cache (bool, tùy chọn, mặc định là True) — Có xóa bộ nhớ đệm của thiết bị sau khi đặt tensor lên thiết bị hay không.

Một hàm trợ giúp để đặt một tensor (tham số hoặc buffer) nhất định của một module lên một thiết bị cụ thể (lưu ý rằng việc thực hiện param.to(device) sẽ tạo ra một tensor mới không liên kết với tham số, đó là lý do chúng ta cần hàm này).

accelerate.utils.get_module_children_bottom_up

< >

( model: Modulereturn_fqns: bool = False ) → list[torch.nn.Module]

Tham số

  • model (torch.nn.Module) — mô hình cần lấy các phần tử con

Trả về

list[torch.nn.Module]

một danh sách các module con của model theo thứ tự từ dưới lên trên. Phần tử cuối cùng chính là model.

Duyệt mô hình theo thứ tự từ dưới lên và trả về các module con theo thứ tự đó.

Song song

Những tiện ích này bao gồm các tiện ích chung nên được sử dụng khi làm việc song song.

accelerate.utils.extract_model_from_parallel

< >

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

Tham số

  • model (torch.nn.Module) — Mô hình cần trích xuất.
  • keep_fp32_wrapper (bool, tuỳ chọn) — Có nên gỡ bỏ các hook độ chính xác hỗn hợp khỏi mô hình hay không.
  • keep_torch_compile (bool, tùy chọn) — Có nên gỡ bỏ lớp bọc của mô hình đã biên dịch hay không.
  • recursive (bool, tuỳ chọn, mặc định là False) — Có nên đệ quy trích xuất tất cả các trường hợp của module.module từ model cũng như mở bọc đệ quy các lớp con trực thuộc, thay vì chỉ các container phân phối ở cấp cao nhất hay không.

Trả về

torch.nn.Module

Mô hình đã được trích xuất.

Trích xuất một mô hình từ các container phân tán của nó.

accelerate.utils.save

< >

( objfsave_on_each_node: bool = Falsesafe_serialization: bool = False )

Tham số

  • obj — Dữ liệu cần lưu
  • f — Tệp (hoặc đối tượng giống tệp) được sử dụng để lưu trữ dữ liệu
  • save_on_each_node (bool, tùy chọn, mặc định là False) — Có chỉ lưu trên tiến trình chính toàn cục hay không
  • safe_serialization (bool, tùy chọn, mặc định là False) — Có nên lưu obj bằng safetensors hay theo cách truyền thống của PyTorch (sử dụng pickle) hay không.

Lưu dữ liệu xuống đĩa. Sử dụng thay cho torch.save().

accelerate.utils.load

< >

( fmap_location = None**kwargs )

Tham số

  • f — Tệp (hoặc đối tượng giống tệp) được sử dụng để tải dữ liệu
  • map_location — một hàm, torch.device, chuỗi hoặc dict chỉ định cách ánh xạ lại các vị trí lưu trữ
  • **kwargs — Các đối số từ khóa bổ sung để truyền cho torch.load().

Thay thế tương thích hoàn toàn cho torch.load(), cho phép sử dụng weights_only nếu phiên bản torch là 2.4.0 trở lên. Nếu không, tham số này sẽ bị bỏ qua.

Cũng sẽ thêm (và sau đó gỡ bỏ) một ngoại lệ cho mảng numpy

accelerate.utils.wait_for_everyone

< >

( )

Giới thiệu một điểm chặn trong script, đảm bảo tất cả các tiến trình đã đạt đến điểm này trước khi tiếp tục.

Hãy đảm bảo tất cả các tiến trình đều thực hiện đến chỉ lệnh này, nếu không một trong các tiến trình của bạn sẽ treo vĩnh viễn.

Ngẫu nhiên

Các tiện ích này liên quan đến việc thiết lập và đồng bộ hóa tất cả các trạng thái ngẫu nhiên.

accelerate.utils.set_seed

< >

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

Tham số

  • seed (int) — Hạt giống cần thiết lập.
  • device_specific (bool, tùy chọn, mặc định là False) — Có nên thay đổi nhẹ hạt giống (seed) trên mỗi thiết bị bằng self.process_index hay không.
  • deterministic (bool, tùy chọn, mặc định là False) — Có sử dụng các thuật toán tất định khi có sẵn hay không. Có thể làm chậm quá trình huấn luyện.

Hàm phụ trợ cho hành vi có thể tái lập để đặt hạt giống trong random, numpy, torch.

accelerate.utils.synchronize_rng_state

< >

( rng_type: accelerate.utils.dataclasses.RNGType | None = Nonegenerator: torch.Generator | None = None )

accelerate.synchronize_rng_states

< >

( rng_types: listgenerator: torch.Generator | None = None )

PyTorch XLA

Những tiện ích này bao gồm các công cụ hữu ích khi sử dụng PyTorch với XLA.

accelerate.utils.install_xla

< >

( upgrade: bool = False )

Tham số

  • upgrade (bool, tùy chọn, mặc định là False) — Có nâng cấp torch và cài đặt các bánh xe torch_xla mới nhất hay không.

Hàm phụ trợ để cài đặt các bánh xe xla phù hợp dựa trên phiên bản torch trong Google Colaboratory.

Ví dụ:

>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)

Tải trọng số mô hình

Những tiện ích này bao gồm các công cụ hữu ích để tải 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 )

Tham số

  • model (torch.nn.Module) — Mô hình mà chúng ta muốn nạp checkpoint vào.
  • checkpoint (str hoặc os.PathLike) — Checkpoint thư mục cần tải. Nó có thể là:
    • đường dẫn đến tệp chứa toàn bộ state dict của mô hình
    • đường dẫn đến tệp .json chứa chỉ mục của checkpoint phân mảnh
    • đường dẫn đến một thư mục chứa tệp .index.json duy nhất và các shard của checkpoint.
    • đường dẫn đến một thư mục chứa tệp pytorch_model.bin hoặc tệp model.safetensors duy nhất.
  • device_map (Dict[str, Union[int, str, torch.device]], tùy chọn) — Một bản đồ chỉ định vị trí của từng submodule. Không cần chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một thiết bị.
  • offload_folder (str hoặc os.PathLike, tùy chọn) — Nếu device_map chứa bất kỳ giá trị nào là "disk", đây là thư mục nơi chúng ta sẽ offload trọng số.
  • dtype (str hoặc torch.dtype, tùy chọn) — Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi tải.
  • offload_state_dict (bool, tùy chọn, mặc định là False) — Nếu True, sẽ tạm thời offload state dict CPU xuống ổ cứng để tránh hết RAM CPU nếu trọng số của state dict CPU + shard lớn nhất không vừa.
  • offload_buffers (bool, tùy chọn, mặc định là False) — Có bao gồm các buffer trong các trọng số được offload xuống đĩa hay không.
  • keep_in_fp32_modules(List[str], tuỳ chọn) — Danh sách các module mà chúng ta giữ ở kiểu dữ liệu torch.float32.
  • offload_8bit_bnb (bool, tùy chọn) — Có bật offload các module 8-bit lên cpu/disk hay không.
  • strict (bool, tùy chọn, mặc định là False) — Có nên thực thi nghiêm ngặt việc các khóa trong state_dict của checkpoint khớp với các khóa của state_dict của mô hình hay không.
  • full_state_dict (bool, tùy chọn, mặc định là True) — nếu được đặt thành True, tất cả các tensor trong state_dict đã tải sẽ được gom lại. Không có ShardedTensor và DTensor nào trong state_dict đã tải.
  • broadcast_from_rank0 (False, tùy chọn, mặc định là False) — khi tùy chọn này là True, một nhóm tiến trình phân tán ProcessGroup phải được khởi tạo. rank0 sẽ nhận state_dict đầy đủ và phát trực tiếp (broadcast) các tensor trong state_dict lần lượt đến các rank khác. Các rank khác sẽ nhận các tensor và chia nhỏ (shard, nếu áp dụng) theo các shard cục bộ trong mô hình.

Tải một checkpoint (có thể được chia mảnh) bên trong một model, đồng thời có thể gửi các trọng số đến một thiết bị đã cho trong khi chúng được tải.

Sau khi được nạp trên các thiết bị, bạn vẫn cần gọi dispatch_model() trên mô hình của mình để nó có thể chạy. Để nhóm việc nạp checkpoint và dispatch vào một lần gọi duy nhất, hãy sử dụng load_checkpoint_and_dispatch().

Lượng tử hóa

Những tiện ích này bao gồm các công cụ hữu ích để lượng tử hóa mô hình.

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

Tham số

  • model (torch.nn.Module) — Mô hình đầu vào. Mô hình có thể đã được tải hoặc đang trên thiết bị meta
  • bnb_quantization_config (BnbQuantizationConfig) — Các tham số lượng tử hóa bitsandbytes
  • weights_location (str hoặc os.PathLike) — Thư mục weights_location để tải. Nó có thể là:
    • đường dẫn đến tệp chứa toàn bộ state dict của mô hình
    • đường dẫn đến tệp .json chứa chỉ mục của checkpoint phân mảnh
    • đường dẫn đến một thư mục chứa tệp .index.json duy nhất và các shard của checkpoint.
    • đường dẫn đến một thư mục chứa tệp pytorch_model.bin duy nhất.
  • device_map (Dict[str, Union[int, str, torch.device]], tùy chọn) — Một bản đồ chỉ định vị trí của từng submodule. Không cần chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một thiết bị.
  • no_split_module_classes (List[str], tùy chọn) — Một danh sách tên lớp lớp (layer class) không bao giờ được phép tách ra giữa các thiết bị (ví dụ bất kỳ lớp nào có kết nối dư (residual connection)).
  • max_memory (Dict, tùy chọn) — Một từ điển ánh xạ định danh thiết bị tới bộ nhớ tối đa. Nếu không được đặt, giá trị mặc định sẽ là bộ nhớ tối đa khả dụng.
  • offload_folder (str hoặc os.PathLike, tùy chọn) — Nếu device_map chứa bất kỳ giá trị nào là "disk", đây là thư mục nơi chúng ta sẽ offload trọng số.
  • offload_state_dict (bool, tùy chọn, mặc định là False) — Nếu True, sẽ tạm thời offload state dict CPU xuống ổ cứng để tránh hết RAM CPU nếu trọng số của state dict CPU + shard lớn nhất không vừa.

Trả về

torch.nn.Module

Mô hình đã lượng tử hóa

Hàm này sẽ lượng tử hóa mô hình đầu vào với cấu hình liên quan được truyền vào bnb_quantization_config. Nếu mô hình đang ở trên thiết bị meta, chúng tôi sẽ tải và phân phối các trọng số theo device_map được truyền vào. Nếu mô hình đã được tải, chúng tôi sẽ lượng tử hóa mô hình và đặt mô hình lên GPU,

Update on GitHub

←FP8 Công cụ tiện ích của Megatron-LM→