Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Referensi SageMaker model parallel library v2 Berikut ini adalah referensi untuk SageMaker model parallel library v2 (SMP v2). **Topics** + [Parameter konfigurasi fitur inti SMP v2](#distributed-model-parallel-v2-reference-init-config) + [Referensi untuk paket SMP v2 `torch.sagemaker`](#model-parallel-v2-torch-sagemaker-reference) + [Tingkatkan dari SMP v1 ke SMP v2](#model-parallel-v2-upgrade-from-v1) ## Parameter konfigurasi fitur inti SMP v2 Berikut ini adalah daftar lengkap parameter untuk mengaktifkan dan mengkonfigurasi[Fitur inti dari perpustakaan paralelisme SageMaker model v2](model-parallel-core-features-v2.md). Ini harus ditulis dalam format JSON dan diteruskan ke PyTorch estimator di SDK SageMaker Python atau disimpan sebagai file JSON untuk. SageMaker HyperPod ``` { "hybrid_shard_degree": Integer, "sm_activation_offloading": Boolean, "activation_loading_horizon": Integer, "fsdp_cache_flush_warnings": Boolean, "allow_empty_shards": Boolean, "tensor_parallel_degree": Integer, "context_parallel_degree": Integer, "expert_parallel_degree": Integer, "random_seed": Integer } ``` + `hybrid_shard_degree`(Integer) - Menentukan derajat paralelisme sharded. Nilai harus berupa bilangan bulat antara `0` dan`world_size`. Nilai default-nya adalah `0`. + Jika disetel ke`0`, itu kembali ke PyTorch implementasi asli dan API dalam skrip saat `tensor_parallel_degree` 1. Jika tidak, itu menghitung kemungkinan terbesar `hybrid_shard_degree` berdasarkan `tensor_parallel_degree` dan`world_size`. Saat kembali ke kasus penggunaan PyTorch FSDP asli, jika strategi `FULL_SHARD` yang Anda gunakan, itu akan terbagi di seluruh cluster. GPUs Jika `HYBRID_SHARD` atau `_HYBRID_SHARD_ZERO2` apakah strateginya, itu setara `hybrid_shard_degree` dengan 8. Ketika paralelisme tensor diaktifkan, itu memecah berdasarkan revisi. `hybrid_shard_degree` + Jika disetel ke`1`, itu kembali ke PyTorch implementasi asli dan API untuk `NO_SHARD` dalam skrip saat `tensor_parallel_degree` 1. Jika tidak, itu setara dengan `NO_SHARD` dalam grup paralel tensor tertentu. + Jika disetel ke bilangan bulat antara 2 dan`world_size`, sharding terjadi di seluruh jumlah yang ditentukan. GPUs Jika Anda tidak mengatur `sharding_strategy` skrip FSDP, itu akan diganti menjadi. `HYBRID_SHARD` Jika Anda mengatur`_HYBRID_SHARD_ZERO2`, yang `sharding_strategy` Anda tentukan digunakan. + `sm_activation_offloading`(Boolean) - Menentukan apakah akan mengaktifkan implementasi pembongkaran aktivasi SMP. Jika`False`, pembongkaran menggunakan PyTorch implementasi asli. Jika`True`, ia menggunakan implementasi pembongkaran aktivasi SMP. Anda juga perlu menggunakan PyTorch aktivasi offload wrapper (`torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper`) dalam skrip Anda. Untuk mempelajari selengkapnya, lihat [Pembongkaran aktivasi](model-parallel-core-features-v2-pytorch-activation-offloading.md). Nilai default-nya adalah `True`. + `activation_loading_horizon`(Integer) - Bilangan bulat yang menentukan jenis horizon pembongkaran aktivasi untuk FSDP. Ini adalah jumlah maksimum lapisan checkpoint atau offloaded yang inputnya dapat berada di memori GPU secara bersamaan. Untuk mempelajari selengkapnya, lihat [Pembongkaran aktivasi](model-parallel-core-features-v2-pytorch-activation-offloading.md). Nilai masukan harus berupa bilangan bulat positif. Nilai default-nya adalah `2`. + `fsdp_cache_flush_warnings`(Boolean) - Mendeteksi dan memperingatkan jika cache flush terjadi di manajer PyTorch memori, karena mereka dapat menurunkan kinerja komputasi. Nilai default-nya adalah `True`. + `allow_empty_shards`(Boolean) — Apakah akan mengizinkan pecahan kosong saat sharding tensor jika tensor tidak habis dibagi. Ini adalah perbaikan eksperimental untuk crash selama checkpointing dalam skenario tertentu. Menonaktifkan ini kembali ke perilaku aslinya PyTorch . Nilai default-nya adalah `False`. + `tensor_parallel_degree`(Integer) - Menentukan derajat paralelisme tensor. Nilai harus antara `1` dan`world_size`. Nilai default-nya adalah `1`. Perhatikan bahwa meneruskan nilai yang lebih besar dari 1 tidak mengaktifkan paralelisme konteks secara otomatis; Anda juga perlu menggunakan [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) API untuk membungkus model dalam skrip pelatihan Anda. Untuk mempelajari selengkapnya, lihat [Paralelisme tensor](model-parallel-core-features-v2-tensor-parallelism.md). + `context_parallel_degree`(Integer) - Menentukan tingkat paralelisme konteks. Nilai harus antara `1` dan`world_size`, dan harus`<= hybrid_shard_degree`. Nilai default-nya adalah `1`. Perhatikan bahwa meneruskan nilai yang lebih besar dari 1 tidak mengaktifkan paralelisme konteks secara otomatis; Anda juga perlu menggunakan [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) API untuk membungkus model dalam skrip pelatihan Anda. Untuk mempelajari selengkapnya, lihat [Paralelisme konteks](model-parallel-core-features-v2-context-parallelism.md). + `expert_parallel_degree`(Integer) - Menentukan tingkat paralelisme ahli. Nilai harus antara 1 dan`world_size`. Nilai default-nya adalah `1`. Perhatikan bahwa meneruskan nilai yang lebih besar dari 1 tidak mengaktifkan paralelisme konteks secara otomatis; Anda juga perlu menggunakan [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) API untuk membungkus model dalam skrip pelatihan Anda. Untuk mempelajari selengkapnya, lihat [Paralelisme ahli](model-parallel-core-features-v2-expert-parallelism.md). + `random_seed`(Integer) — Nomor benih untuk operasi acak dalam modul terdistribusi oleh paralelisme tensor SMP atau paralelisme ahli. Benih ini ditambahkan ke peringkat tensor-paralel atau paralel ahli untuk menetapkan benih aktual untuk setiap peringkat. Ini unik untuk setiap peringkat tensor-paralel dan paralel ahli. SMP v2 memastikan bahwa nomor acak yang dihasilkan di seluruh peringkat tensor-paralel dan paralel ahli masing-masing cocok dengan kasus dan. non-tensor-parallelism non-expert-parallelism ## Referensi untuk paket SMP v2 `torch.sagemaker` Bagian ini adalah referensi untuk `torch.sagemaker` paket yang disediakan oleh SMP v2. **Topics** + [`torch.sagemaker.delayed_param.DelayedParamIniter`](#model-parallel-v2-torch-sagemaker-reference-delayed-param-init) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-async-save) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-state-dict-saver) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-save) + [`torch.sagemaker.distributed.checkpoint.state_dict_loader.load`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-load) + [`torch.sagemaker.moe.moe_config.MoEConfig`](#model-parallel-v2-torch-sagemaker-reference-moe) + [`torch.sagemaker.nn.attn.FlashSelfAttention`](#model-parallel-v2-torch-sagemaker-reference-flashselfattention) + [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) + [`torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention`](#model-parallel-v2-torch-sagemaker-reference-llamaFlashAttn) + [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) + [`torch.sagemaker`fungsi dan properti util](#model-parallel-v2-torch-sagemaker-reference-utils) ### `torch.sagemaker.delayed_param.DelayedParamIniter` API untuk diterapkan [Inisialisasi parameter tertunda](model-parallel-core-features-v2-delayed-param-init.md) ke PyTorch model. ``` class torch.sagemaker.delayed_param.DelayedParamIniter( model: nn.Module, init_method_using_config : Callable = None, verbose: bool = False, ) ``` **Parameter** + `model`(`nn.Module`) — PyTorch Model untuk membungkus dan menerapkan fungsionalitas inisialisasi parameter tertunda SMP v2. + `init_method_using_config`(Dapat dipanggil) — Jika Anda menggunakan implementasi paralel tensor SMP v2 atau didukung[Model Hugging Face Transformer kompatibel dengan paralelisme tensor SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models), pertahankan parameter ini pada nilai default, yaitu. `None` Secara default, `DelayedParamIniter` API mengetahui cara menginisialisasi model yang diberikan dengan benar. Untuk model lain, Anda perlu membuat fungsi inisialisasi parameter khusus dan menambahkannya ke skrip Anda. Cuplikan kode berikut adalah `init_method_using_config` fungsi default yang diterapkan SMP v2 untuk. [Model Hugging Face Transformer kompatibel dengan paralelisme tensor SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) Gunakan cuplikan kode berikut sebagai referensi untuk membuat fungsi konfigurasi inisialisasi Anda sendiri, menambahkannya ke skrip Anda, dan meneruskannya ke `init_method_using_config` parameter API SMP. `DelayedParamIniter` ``` from torch.sagemaker.utils.module_utils import empty_module_params, move_buffers_to_device # Define a custom init config function. def custom_init_method_using_config(module): d = torch.cuda.current_device() empty_module_params(module, device=d) if isinstance(module, (nn.Linear, Conv1D)): module.weight.data.normal_(mean=0.0, std=config.initializer_range) if module.bias is not None: module.bias.data.zero_() elif isinstance(module, nn.Embedding): module.weight.data.normal_(mean=0.0, std=config.initializer_range) if module.padding_idx is not None: module.weight.data[module.padding_idx].zero_() elif isinstance(module, nn.LayerNorm): module.weight.data.fill_(1.0) module.bias.data.zero_() elif isinstance(module, LlamaRMSNorm): module.weight.data.fill_(1.0) move_buffers_to_device(module, device=d) delayed_initer = DelayedParamIniter(model, init_method_using_config=custom_init_method_using_config) ``` Untuk informasi selengkapnya tentang `torch.sagemaker.module_util` fungsi dalam cuplikan kode sebelumnya, lihat. [`torch.sagemaker`fungsi dan properti util](#model-parallel-v2-torch-sagemaker-reference-utils) + `verbose`(Boolean) - Apakah akan mengaktifkan logging yang lebih rinci selama inisialisasi dan validasi. Nilai default-nya adalah `False`. **Metode** + `get_param_init_fn()`— Mengembalikan fungsi inisialisasi parameter yang dapat Anda lewatkan ke `param_init_fn` argumen kelas pembungkus PyTorch FSDP. + `get_post_param_init_fn()`— Mengembalikan fungsi inisialisasi parameter yang dapat Anda lewatkan ke `post_param_init_fn` argumen kelas pembungkus PyTorch FSDP. Ini diperlukan ketika Anda telah mengikat bobot dalam model. Model harus menerapkan metode`tie_weights`. Untuk informasi selengkapnya, lihat **Catatan tentang bobot terikat**[Inisialisasi parameter tertunda](model-parallel-core-features-v2-delayed-param-init.md). + `count_num_params`(`module: nn.Module, *args: Tuple[nn.Parameter]`) — Melacak berapa banyak parameter yang diinisialisasi oleh fungsi inisialisasi parameter. Ini membantu menerapkan `validate_params_and_buffers_inited` metode berikut. Anda biasanya tidak perlu memanggil fungsi ini secara eksplisit, karena metode ini secara implisit memanggil `validate_params_and_buffers_inited` metode ini di backend. + `validate_params_and_buffers_inited`(`enabled: bool=True`) — Ini adalah manajer konteks yang membantu memvalidasi bahwa jumlah parameter yang diinisialisasi cocok dengan jumlah total parameter dalam model. Ini juga memvalidasi bahwa semua parameter dan buffer sekarang ada di perangkat GPU, bukan perangkat meta. Ini memunculkan `AssertionErrors` jika kondisi ini tidak terpenuhi. Pengelola konteks ini hanya opsional dan Anda tidak diharuskan menggunakan pengelola konteks ini untuk menginisialisasi parameter. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save` Entri API untuk penyimpanan asinkron. Gunakan metode ini untuk menyimpan `state_dict` asinkron ke yang ditentukan. `checkpoint_id` ``` def async_save( state_dict: STATE_DICT_TYPE, *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_writer: Optional[StorageWriter] = None, planner: Optional[SavePlanner] = None, process_group: Optional[dist.ProcessGroup] = None, coordinator_rank: int = 0, queue : AsyncCallsQueue = None, sharded_strategy: Union[SaveShardedStrategy, Tuple[str, int], None] = None, wait_error_handling: bool = True, force_check_all_plans: bool = True, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parameter** + `state_dict`(dict) - Diperlukan. Dikte negara untuk menyelamatkan. + `checkpoint_id`(str) - Diperlukan. Jalur penyimpanan untuk menyimpan pos pemeriksaan ke. + `storage_writer`(StorageWriter) - Opsional. Sebuah contoh dari [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)dalam PyTorch untuk melakukan operasi tulis. Jika ini tidak spesifik, konfigurasi default [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)digunakan. + `planner`(SavePlanner) - Opsional. Sebuah contoh dari [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)dalam PyTorch. Jika ini tidak spesifik, konfigurasi default [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)digunakan. + `process_group`(ProcessGroup) - Opsional. Kelompok proses untuk dikerjakan. Jika`None`, grup proses default (global) digunakan. + `coordinator_rank`(int) - Opsional. Pangkat koordinator saat melakukan operator komunikasi kolektif seperti`AllReduce`. + `queue`(AsyncRequestQueue) - Opsional. Penjadwal async untuk digunakan. Secara default, dibutuhkan parameter global`DEFAULT_ASYNC_REQUEST_QUEUE`. + `sharded_strategy`(PyTorchDistSaveShardedStrategy) - Opsional. Strategi sharded yang digunakan untuk menyimpan pos pemeriksaan. Jika ini tidak ditentukan, `torch.sagemaker.distributed.checkpoint.state_dict_saver.PyTorchDistSaveShardedStrategy` digunakan secara default. + `wait_error_handling`(bool) - Opsional. Bendera yang menentukan apakah akan menunggu semua peringkat untuk menyelesaikan penanganan kesalahan. Nilai default-nya adalah `True`. + `force_check_all_plans`(bool) - Opsional. Bendera yang menentukan apakah akan menyinkronkan rencana secara paksa di seluruh peringkat, bahkan dalam kasus hit cache. Nilai default-nya adalah `True`. + `s3_region`(str) - Opsional. Wilayah tempat ember S3 berada. Jika tidak ditentukan, wilayah tersebut disimpulkan dari. `checkpoint_id` + `s3client_config`(S3ClientConfig) - Opsional. Dataclass mengekspos parameter yang dapat dikonfigurasi untuk klien S3. Jika tidak disediakan, konfigurasi default [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) digunakan. `part_size`Parameter diatur ke 64MB secara default. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls` Fungsi ini memungkinkan proses pelatihan untuk memantau beberapa permintaan asinkron yang harus dilakukan. ``` def maybe_finalize_async_calls( blocking=True, process_group=None ) -> List[int]: ``` **Parameter** + `blocking`(bool) - Opsional. Jika`True`, itu akan menunggu sampai semua permintaan aktif selesai. Jika tidak, itu hanya menyelesaikan permintaan asinkron yang telah selesai. Nilai default-nya adalah `True`. + `process_group`(ProcessGroup) - Opsional. Kelompok proses untuk beroperasi. Jika disetel ke`None`, grup proses default (global) digunakan. **Pengembalian** + Daftar yang berisi indeks panggilan asinkron berhasil diselesaikan. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.save` Gunakan metode ini untuk menyimpan `state_dict` sinkron ke yang ditentukan`checkpoint_id`. ``` def save( state_dict: STATE_DICT_TYPE, *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_writer: Optional[StorageWriter] = None, planner: Optional[SavePlanner] = None, process_group: Optional[dist.ProcessGroup] = None, coordinator_rank: int = 0, wait_error_handling: bool = True, force_check_all_plans: bool = True, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parameter** + `state_dict`(dict) - Diperlukan. Dikte negara untuk menyelamatkan. + `checkpoint_id`(str) - Diperlukan. Jalur penyimpanan untuk menyimpan pos pemeriksaan ke. + `storage_writer`(StorageWriter) - Opsional. Sebuah contoh dari [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)dalam PyTorch untuk melakukan operasi tulis. Jika ini tidak spesifik, konfigurasi default [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)digunakan. + `planner`(SavePlanner) - Opsional. Sebuah contoh dari [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)dalam PyTorch. Jika ini tidak spesifik, konfigurasi default [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)digunakan. + `process_group`(ProcessGroup) - Opsional. Kelompok proses untuk dikerjakan. Jika`None`, grup proses default (global) digunakan. + `coordinator_rank`(int) - Opsional. Pangkat koordinator saat melakukan operator komunikasi kolektif seperti`AllReduce`. + `wait_error_handling`(bool) - Opsional. Bendera yang menentukan apakah akan menunggu semua peringkat untuk menyelesaikan penanganan kesalahan. Nilai default-nya adalah `True`. + `force_check_all_plans`(bool) - Opsional. Bendera yang menentukan apakah akan menyinkronkan rencana secara paksa di seluruh peringkat, bahkan dalam kasus hit cache. Nilai default-nya adalah `True`. + `s3_region`(str) - Opsional. Wilayah tempat ember S3 berada. Jika tidak ditentukan, wilayah tersebut disimpulkan dari. `checkpoint_id` + `s3client_config`(S3ClientConfig) - Opsional. Dataclass mengekspos parameter yang dapat dikonfigurasi untuk klien S3. Jika tidak disediakan, konfigurasi default [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) digunakan. `part_size`Parameter diatur ke 64MB secara default. ### `torch.sagemaker.distributed.checkpoint.state_dict_loader.load` Muat kamus negara dari model terdistribusi (`state_dict`). ``` def load( state_dict: Dict[str, Any], *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_reader: Optional[StorageReader] = None, planner: Optional[LoadPlanner] = None, process_group: Optional[dist.ProcessGroup] = None, check_keys_matched: bool = True, coordinator_rank: int = 0, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parameter** + `state_dict`(dict) - Diperlukan. `state_dict`Untuk memuat. + `checkpoint_id`(str) - Diperlukan. ID pos pemeriksaan. Arti dari `checkpoint_id` tergantung pada penyimpanan. Ini bisa berupa jalur ke folder atau ke file. Ini juga bisa menjadi kunci jika penyimpanan adalah penyimpanan nilai kunci. + `storage_reader`(StorageReader) - Opsional. Contoh [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader)dalam PyTorch untuk melakukan operasi baca. Jika tidak ditentukan, pos pemeriksaan terdistribusi akan secara otomatis menyimpulkan pembaca berdasarkan. `checkpoint_id` Jika `checkpoint_id` juga`None`, kesalahan pengecualian muncul. + `planner`(StorageReader) - Opsional. Sebuah contoh dari [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner)dalam PyTorch. Jika tidak spesifik, konfigurasi default [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner)digunakan. + `check_keys_matched`(bool) - Opsional. Jika diaktifkan, periksa apakah `state_dict` kunci dari semua peringkat cocok menggunakan`AllGather`. + `s3_region`(str) - Opsional. Wilayah tempat ember S3 berada. Jika tidak ditentukan, wilayah tersebut disimpulkan dari. `checkpoint_id` + `s3client_config`(S3ClientConfig) - Opsional. Dataclass mengekspos parameter yang dapat dikonfigurasi untuk klien S3. Jika tidak disediakan, konfigurasi default [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) digunakan. `part_size`Parameter diatur ke 64MB secara default. ### `torch.sagemaker.moe.moe_config.MoEConfig` Sebuah kelas konfigurasi untuk menyiapkan implementasi SMP Mixture-of-Experts (MoE). Anda dapat menentukan nilai konfigurasi MoE melalui kelas ini dan meneruskannya ke panggilan [https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform)API. Untuk mempelajari lebih lanjut tentang penggunaan kelas ini untuk melatih model MoE, lihat[Paralelisme ahli](model-parallel-core-features-v2-expert-parallelism.md). ``` class torch.sagemaker.moe.moe_config.MoEConfig( smp_moe=True, random_seed=12345, moe_load_balancing="sinkhorn", global_token_shuffle=False, moe_all_to_all_dispatcher=True, moe_aux_loss_coeff=0.001, moe_z_loss_coeff=0.001 ) ``` **Parameter** + `smp_moe`(Boolean) - Apakah akan menggunakan implementasi SMP dari MoE. Nilai default-nya adalah `True`. + `random_seed`(Integer) - Nomor benih untuk operasi acak dalam modul terdistribusi paralel ahli. Benih ini ditambahkan ke peringkat paralel ahli untuk menetapkan benih aktual untuk setiap peringkat. Ini unik untuk setiap peringkat paralel ahli. Nilai default-nya adalah `12345`. + `moe_load_balancing`(String) - Tentukan jenis load balancing dari router MoE. Opsi yang valid adalah`aux_loss`,`sinkhorn`,`balanced`, dan`none`. Nilai default-nya adalah `sinkhorn`. + `global_token_shuffle`(Boolean) - Apakah akan mengacak token di seluruh peringkat EP dalam grup EP yang sama. Nilai default-nya adalah `False`. + `moe_all_to_all_dispatcher`(Boolean) - Apakah akan menggunakan all-to-all dispatcher untuk komunikasi di MoE. Nilai default-nya adalah `True`. + `moe_aux_loss_coeff`(Float) - Koefisien untuk kerugian penyeimbangan beban tambahan. Nilai default-nya adalah `0.001`. + `moe_z_loss_coeff`(Float) - Koefisien untuk z-loss. Nilai default-nya adalah `0.001`. ### `torch.sagemaker.nn.attn.FlashSelfAttention` API untuk digunakan [FlashAttention](model-parallel-core-features-v2-flashattention.md) dengan SMP v2. ``` class torch.sagemaker.nn.attn.FlashSelfAttention( attention_dropout_prob: float = 0.0, scale: Optional[float] = None, triton_flash_attention: bool = False, use_alibi: bool = False, ) ``` **Parameter** + `attention_dropout_prob`(float) — Probabilitas putus sekolah untuk diterapkan pada perhatian. Nilai default-nya adalah `0.0`. + `scale`(float) — Jika lulus, faktor skala ini diterapkan untuk softmax. Jika disetel ke `None` (yang juga merupakan nilai default), faktor skalanya adalah`1 / sqrt(attention_head_size)`. Nilai default-nya adalah `None`. + `triton_flash_attention`(bool) — Jika diteruskan, implementasi Triton dari perhatian flash digunakan. Ini diperlukan untuk mendukung Perhatian dengan Bias Linear (ALiBi) (lihat `use_alibi` parameter berikut). Versi kernel ini tidak mendukung putus sekolah. Nilai default-nya adalah `False`. + `use_alibi`(bool) — Jika diteruskan, ini memungkinkan Perhatian dengan Bias Linear (ALiBi) menggunakan topeng yang disediakan. Saat menggunakan ALi Bi, perlu masker perhatian yang disiapkan sebagai berikut. Nilai default-nya adalah `False`. ``` def generate_alibi_attn_mask(attention_mask, batch_size, seq_length, num_attention_heads, alibi_bias_max=8): device, dtype = attention_mask.device, attention_mask.dtype alibi_attention_mask = torch.zeros( 1, num_attention_heads, 1, seq_length, dtype=dtype, device=device ) alibi_bias = torch.arange(1 - seq_length, 1, dtype=dtype, device=device).view( 1, 1, 1, seq_length ) m = torch.arange(1, num_attention_heads + 1, dtype=dtype, device=device) m.mul_(alibi_bias_max / num_attention_heads) alibi_bias = alibi_bias * (1.0 / (2 ** m.view(1, num_attention_heads, 1, 1))) alibi_attention_mask.add_(alibi_bias) alibi_attention_mask = alibi_attention_mask[..., :seq_length, :seq_length] if attention_mask is not None and attention_mask.bool().any(): alibi_attention_mask.masked_fill( attention_mask.bool().view(batch_size, 1, 1, seq_length), float("-inf") ) return alibi_attention_mask ``` **Metode** + `forward(self, qkv, attn_mask=None, causal=False, cast_dtype=None, layout="b h s d")`- Fungsi PyTorch modul reguler. Ketika a `module(x)` dipanggil, SMP menjalankan fungsi ini secara otomatis. + `qkv`— `torch.Tensor` dari bentuk berikut: `(batch_size x seqlen x (3 x num_heads) x head_size)` atau`(batch_size, (3 x num_heads) x seqlen x head_size)`, tupel yang `torch.Tensors` masing-masing mungkin berbentuk`(batch_size x seqlen x num_heads x head_size)`, atau`(batch_size x num_heads x seqlen x head_size)`. Arg tata letak yang sesuai harus diteruskan berdasarkan bentuknya. + `attn_mask``torch.Tensor`dari bentuk berikut`(batch_size x 1 x 1 x seqlen)`. Untuk mengaktifkan parameter topeng perhatian ini, diperlukan `triton_flash_attention=True` dan`use_alibi=True`. Untuk mempelajari cara membuat topeng perhatian menggunakan metode ini, lihat contoh kode di[FlashAttention](model-parallel-core-features-v2-flashattention.md). Nilai default-nya adalah `None`. + `causal`— Ketika diatur ke`False`, yang merupakan nilai default dari argumen, tidak ada topeng diterapkan. Ketika diatur ke`True`, `forward` metode ini menggunakan topeng segitiga bawah standar. Nilai default-nya adalah `False`. + `cast_dtype`— Ketika diatur ke tertentu`dtype`, itu melemparkan `qkv` tensor ke itu sebelumnya. `dtype` `attn` Ini berguna untuk implementasi seperti model Hugging Face Transformer GPT-Neox, yang memiliki dan dengan after rotary embeddings. `q` `k` `fp32` Jika disetel ke`None`, tidak ada pemeran yang diterapkan. Nilai default-nya adalah `None`. + `layout`(string) - Nilai yang tersedia adalah `b h s d` atau`b s h d`. Ini harus diatur ke tata letak `qkv` tensor yang dilewati, sehingga transformasi yang tepat dapat diterapkan. `attn` Nilai default-nya adalah `b h s d`. **Pengembalian** Single `torch.Tensor` dengan bentuk`(batch_size x num_heads x seq_len x head_size)`. ### `torch.sagemaker.nn.attn.FlashGroupedQueryAttention` API untuk digunakan `FlashGroupedQueryAttention` dengan SMP v2. Untuk mempelajari lebih lanjut tentang penggunaan API ini, lihat[Gunakan FlashAttention kernel untuk perhatian kueri yang dikumpulkan](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query). ``` class torch.sagemaker.nn.attn.FlashGroupedQueryAttention( attention_dropout_prob: float = 0.0, scale: Optional[float] = None, ) ``` **Parameter** + `attention_dropout_prob`(float) — Probabilitas putus sekolah untuk diterapkan pada perhatian. Nilai default-nya adalah `0.0`. + `scale`(float) — Jika lulus, faktor skala ini diterapkan untuk softmax. Jika diatur ke`None`, `1 / sqrt(attention_head_size)` digunakan sebagai faktor skala. Nilai default-nya adalah `None`. **Metode** + `forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")`- Fungsi PyTorch modul reguler. Ketika a `module(x)` dipanggil, SMP menjalankan fungsi ini secara otomatis. + `q`— `torch.Tensor` dari bentuk berikut `(batch_size x seqlen x num_heads x head_size)` atau`(batch_size x num_heads x seqlen x head_size)`. Arg tata letak yang sesuai harus dilewatkan berdasarkan bentuknya. + `kv`— `torch.Tensor` dari bentuk berikut `(batch_size x seqlen x (2 x num_heads) x head_size)` atau`(batch_size, (2 x num_heads) x seqlen x head_size)`, atau tupel dua `torch.Tensor` s, yang masing-masing mungkin berbentuk `(batch_size x seqlen x num_heads x head_size)` atau`(batch_size x num_heads x seqlen x head_size)`. `layout`Argumen yang tepat juga harus diteruskan berdasarkan bentuknya. + `causal`— Ketika diatur ke`False`, yang merupakan nilai default dari argumen, tidak ada topeng diterapkan. Ketika diatur ke`True`, `forward` metode ini menggunakan topeng segitiga bawah standar. Nilai default-nya adalah `False`. + `cast_dtype`— Ketika diatur ke dtype tertentu, itu melemparkan `qkv` tensor ke dtype itu sebelumnya. `attn` Ini berguna untuk implementasi seperti Hugging Face Transformers GPT-Neox, yang memiliki dengan after rotary embeddings. `q,k` `fp32` Jika disetel ke`None`, tidak ada pemeran yang diterapkan. Nilai default-nya adalah `None`. + layout (string) - Nilai yang tersedia adalah `"b h s d"` atau`"b s h d"`. Ini harus diatur ke tata letak `qkv` tensor yang dilewati, sehingga transformasi yang tepat dapat diterapkan. `attn` Nilai default-nya adalah `"b h s d"`. **Pengembalian** Mengembalikan satu `torch.Tensor (batch_size x num_heads x seq_len x head_size)` yang mewakili output dari perhitungan perhatian. ### `torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention` API yang mendukung FlashAttention model Llama. API ini menggunakan [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) API pada level rendah. Untuk mempelajari cara menggunakan ini, lihat[Gunakan FlashAttention kernel untuk perhatian kueri yang dikumpulkan](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query). ``` class torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention( config: LlamaConfig ) ``` **Parameter** + `config`— FlashAttention Konfigurasi untuk model Llama. **Metode** + `forward(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)` + `hidden_states`(`torch.Tensor`) — Keadaan tersembunyi dari tensor dalam bentuk. `(batch_size x seq_len x num_heads x head_size)` + `attention_mask`(`torch.LongTensor`) — Topeng untuk menghindari perhatian pada indeks token padding dalam bentuk. `(batch_size x seqlen)` Nilai default-nya adalah `None`. + `position_ids`(`torch.LongTensor`) — Ketika tidak`None`, itu dalam bentuk`(batch_size x seqlen)`, menunjukkan indeks posisi setiap token urutan input dalam embeddings posisi. Nilai default-nya adalah `None`. + `past_key_value`(Cache) — Keadaan tersembunyi yang telah dihitung sebelumnya (kunci dan nilai di blok perhatian diri dan di blok perhatian silang). Nilai default-nya adalah `None`. + `output_attentions`(bool) — Menunjukkan apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Nilai default-nya adalah `False`. + `use_cache`(bool) - Menunjukkan apakah akan mengembalikan status nilai `past_key_values` kunci. Nilai default-nya adalah `False`. **Pengembalian** Mengembalikan satu `torch.Tensor (batch_size x num_heads x seq_len x head_size)` yang mewakili output dari perhitungan perhatian. ### `torch.sagemaker.transform` SMP v2 menyediakan `torch.sagemaker.transform()` API ini untuk mengubah model Hugging Face Transformer menjadi implementasi model SMP dan mengaktifkan paralelisme tensor SMP. ``` torch.sagemaker.transform( model: nn.Module, device: Optional[torch.device] = None, dtype: Optional[torch.dtype] = None, config: Optional[Dict] = None, load_state_dict_from_rank0: bool = False, cp_comm_type: str = "p2p" ) ``` SMP v2 mempertahankan kebijakan transformasi untuk [Model Hugging Face Transformer kompatibel dengan paralelisme tensor SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) dengan mengubah konfigurasi model Hugging Face Transformer ke konfigurasi transformator SMP. **Parameter** + `model`(`torch.nn.Module`) — Model dari [Model Hugging Face Transformer kompatibel dengan paralelisme tensor SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) untuk mengubah dan menerapkan fitur paralelisme tensor dari perpustakaan SMP. + `device`(`torch.device`) — Jika diteruskan, model baru dibuat pada perangkat ini. Jika modul asli memiliki parameter apa pun pada perangkat meta (lihat[Inisialisasi parameter tertunda](model-parallel-core-features-v2-delayed-param-init.md)), maka modul yang diubah juga akan dibuat pada perangkat meta, mengabaikan argumen yang diteruskan di sini. Nilai default-nya adalah `None`. + `dtype`(`torch.dtype`) — Jika diteruskan, tetapkan ini sebagai pengelola konteks dtype untuk pembuatan model dan buat model dengan dtype ini. Ini biasanya tidak perlu, karena kita ingin membuat model dengan `fp32` saat menggunakan`MixedPrecision`, dan `fp32` merupakan dtype default di PyTorch. Nilai default-nya adalah `None`. + `config`(dict) - Ini adalah kamus untuk mengkonfigurasi transformator SMP. Nilai default-nya adalah `None`. + `load_state_dict_from_rank0`(Boolean) - Secara default, modul ini membuat instance baru dari model dengan bobot baru. Ketika argumen ini disetel ke`True`, SMP mencoba memuat kamus status PyTorch model asli dari peringkat 0 menjadi model transformasi untuk grup paralel tensor yang menjadi bagian dari peringkat ke-0. Ketika ini disetel ke`True`, peringkat 0 tidak dapat memiliki parameter apa pun di perangkat meta. Hanya grup paralel tensor pertama yang mengisi bobot dari peringkat ke-0 setelah panggilan transformasi ini. Anda perlu mengatur `sync_module_states` ke `True` dalam pembungkus FSDP untuk mendapatkan bobot ini dari grup paralel tensor pertama ke semua proses lainnya. Dengan ini diaktifkan, perpustakaan SMP memuat kamus status dari model aslinya. Pustaka SMP mengambil model sebelum mentransformasi, mengubahnya agar sesuai dengan struktur model yang ditransformasikan, memotongnya untuk setiap peringkat paralel tensor, mengkomunikasikan keadaan ini dari peringkat ke-0 ke peringkat lain dalam kelompok paralel tensor yang peringkat ke-0 adalah bagian dari, dan memuatnya. `state_dict` Nilai default-nya adalah `False`. + `cp_comm_type`(str) — Menentukan implementasi paralelisme konteks dan hanya berlaku jika lebih besar dari `context_parallel_degree` 1. Nilai yang tersedia untuk parameter ini adalah `p2p` dan`all_gather`. `p2p`Implementasinya menggunakan panggilan peer-to-peer kirim-terima untuk akumulasi tensor key-and-value (KV) selama perhitungan perhatian, berjalan secara asinkron dan memungkinkan komunikasi tumpang tindih dengan komputasi. Di sisi lain, `all_gather` implementasi menggunakan operasi kolektif `AllGather` komunikasi untuk akumulasi tensor KV. Nilai default-nya adalah `"p2p"`. **Pengembalian** Mengembalikan model yang diubah yang dapat Anda bungkus dengan PyTorch FSDP. Kapan `load_state_dict_from_rank0` diatur ke`True`, grup paralel tensor yang melibatkan peringkat 0 memiliki bobot yang dimuat dari kamus status asli pada peringkat 0. Saat menggunakan [Inisialisasi parameter tertunda](model-parallel-core-features-v2-delayed-param-init.md) pada model asli, hanya peringkat ini yang memiliki tensor aktual CPUs untuk parameter dan buffer model yang diubah. Sisa peringkat terus memiliki parameter dan buffer pada perangkat meta untuk menghemat memori. ### `torch.sagemaker`fungsi dan properti util **fungsi obor.sagemaker util** + `torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None`— Menginisialisasi pekerjaan PyTorch pelatihan dengan SMP. + `torch.sagemaker.is_initialized() -> bool`— Memeriksa apakah pekerjaan pelatihan diinisialisasi dengan SMP. Ketika kembali ke asli PyTorch saat pekerjaan diinisialisasi dengan SMP, beberapa properti tidak relevan dan menjadi`None`, seperti yang ditunjukkan dalam daftar **Properti** berikut. + `torch.sagemaker.utils.module_utils.empty_module_params(module: nn.Module, device: Optional[torch.device] = None, recurse: bool = False) -> nn.Module`— Membuat parameter kosong pada yang diberikan `device` jika ada, dan dapat bersifat rekursif untuk semua modul bersarang jika ditentukan. + `torch.sagemaker.utils.module_utils.move_buffers_to_device(module: nn.Module, device: torch.device, recurse: bool = False) -> nn.Module`— Memindahkan buffer modul ke yang diberikan`device`, dan dapat bersifat rekursif untuk semua modul bersarang jika ditentukan. **Sifat-sifat** `torch.sagemaker.state`memegang beberapa properti yang berguna setelah inisialisasi SMP dengan. `torch.sagemaker.init` + `torch.sagemaker.state.hybrid_shard_degree`(int) — Tingkat paralelisme data sharded, salinan dari input pengguna dalam konfigurasi SMP diteruskan ke. `torch.sagemaker.init()` Untuk mempelajari selengkapnya, lihat [Gunakan perpustakaan paralelisme SageMaker model v2](model-parallel-use-api-v2.md). + `torch.sagemaker.state.rank`(int) — Peringkat global untuk perangkat, dalam kisaran`[0, world_size)`. + `torch.sagemaker.state.rep_rank_process_group`(`torch.distributed.ProcessGroup`) — Grup proses termasuk semua perangkat dengan peringkat replikasi yang sama. Perhatikan perbedaan halus namun mendasar dengan`torch.sagemaker.state.tp_process_group`. Ketika jatuh kembali ke asli PyTorch, ia kembali`None`. + `torch.sagemaker.state.tensor_parallel_degree`(int) — Derajat paralelisme tensor, salinan dari input pengguna dalam konfigurasi SMP diteruskan ke. `torch.sagemaker.init()` Untuk mempelajari selengkapnya, lihat [Gunakan perpustakaan paralelisme SageMaker model v2](model-parallel-use-api-v2.md). + `torch.sagemaker.state.tp_size`(int) — Sebuah alias untuk`torch.sagemaker.state.tensor_parallel_degree`. + `torch.sagemaker.state.tp_rank`(int) — Peringkat paralelisme tensor untuk perangkat dalam kisaran`[0, tp_size)`, ditentukan oleh derajat paralelisme tensor dan mekanisme peringkat. + `torch.sagemaker.state.tp_process_group`(`torch.distributed.ProcessGroup`) — Grup proses paralel tensor termasuk semua perangkat dengan peringkat yang sama di dimensi lain (misalnya, paralelisme dan replikasi data sharded) tetapi peringkat paralel tensor yang unik. Ketika jatuh kembali ke asli PyTorch, ia kembali`None`. + `torch.sagemaker.state.world_size`(int) — Jumlah total perangkat yang digunakan dalam pelatihan. ## Tingkatkan dari SMP v1 ke SMP v2 Untuk berpindah dari SMP v1 ke SMP v2, Anda harus membuat perubahan skrip untuk menghapus SMP v1 APIs dan menerapkan SMP v2. APIs Alih-alih memulai dari skrip SMP v1 Anda, kami sarankan Anda memulai dari skrip PyTorch FSDP, dan ikuti instruksi di. [Gunakan perpustakaan paralelisme SageMaker model v2](model-parallel-use-api-v2.md) Untuk membawa *model* SMP v1 ke SMP v2, di SMP v1 Anda harus mengumpulkan kamus status model lengkap dan menerapkan fungsi terjemahan pada kamus status model untuk mengubahnya menjadi format pos pemeriksaan model Hugging Face Transformers. Kemudian di SMP v2, seperti yang dibahas dalam[Checkpointing menggunakan SMP](model-parallel-core-features-v2-checkpoints.md), Anda dapat memuat pos pemeriksaan model Hugging Face Transformers, dan kemudian melanjutkan dengan menggunakan pos pemeriksaan dengan SMP v2. PyTorch APIs Untuk menggunakan SMP dengan model PyTorch FSDP Anda, pastikan Anda pindah ke SMP v2 dan membuat perubahan pada skrip pelatihan Anda untuk menggunakan PyTorch FSDP dan fitur terbaru lainnya. ``` import smdistributed.modelparallel.torch as smp # Create model model = ... model = smp.DistributedModel(model) # Run training ... # Save v1 full checkpoint if smp.rdp_rank() == 0: model_dict = model.state_dict(gather_to_rank0=True) # save the full model # Get the corresponding translation function in smp v1 and translate if model_type == "gpt_neox": from smdistributed.modelparallel.torch.nn.huggingface.gptneox import translate_state_dict_to_hf_gptneox translated_state_dict = translate_state_dict_to_hf_gptneox(state_dict, max_seq_len=None) # Save the checkpoint checkpoint_path = "checkpoint.pt" if smp.rank() == 0: smp.save( {"model_state_dict": translated_state_dict}, checkpoint_path, partial=False, ) ``` Untuk menemukan fungsi terjemahan yang tersedia di SMP v1, lihat. [Support untuk Model Trafo Hugging Face](model-parallel-extended-features-pytorch-hugging-face.md) Untuk instruksi tentang penyimpanan dan pemuatan pos pemeriksaan model di SMP v2, lihat. [Checkpointing menggunakan SMP](model-parallel-core-features-v2-checkpoints.md)