Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Referensi v2 pustaka paralel SageMaker model Berikut ini adalah referensi untuk perpustakaan paralel SageMaker model v2 (SMP v2). **Topics** + [Parameter konfigurasi fitur inti SMP v2](#distributed-model-parallel-v2-reference-init-config) + [Referensi untuk paket SMP v2 `tor` ch.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 ModelTrainer dalam SageMaker Python SDK 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 terpecah-pecah. Nilai harus berupa bilangan bulat antara `0` dan`world_size`. Nilai default-nya adalah `0`. + Jika diset `0` el ke, itu akan kembali ke PyTorch implementasi asli dan API dalam skrip ketika `tensor_parallel_degree` adalah 1. Jika tidak, ia menghitung sebanyak mungkin `hybrid_shard_degree` berdasarkan `tensor_parallel_degree` dan`world_size`. Ketika kembali ke kasus penggunaan PyTorch FSDP asli, jika strategi `FULL_SHARD` yang Anda gunakan, itu terpecah di seluruh cluster GPU. Jika `HYBRID_SHARD` atau `_HYBRID_SHARD_ZERO2` apakah strateginya, itu setara `hybrid_shard_degree` dengan 8. Ketika paralelisme tensor diaktifkan, ia pecah berdasarkan revisi. `hybrid_shard_degree` + Jika diset `1` el ke, itu akan kembali ke PyTorch implementasi asli dan API untuk `NO_SHARD` dalam skrip kapan `tensor_parallel_degree` adalah 1. Jika tidak, itu setara dengan `NO_SHARD` dalam kelompok paralel tensor tertentu. + Jika disetel ke bilangan bulat antara 2 dan`world_size`, sharding terjadi di sejumlah GPU yang ditentukan. Jika Anda tidak mengaturnya `sharding_strategy` di skrip FSDP, skrip tersebut akan diganti ke. `HYBRID_SHARD` Jika Anda mengatur`_HYBRID_SHARD_ZERO2`, yang `sharding_strategy` Anda tentukan digunakan. + `sm_activation_offloading`(Boolean) — Menentukan apakah akan mengaktifkan implementasi offloading aktivasi SMP. Jika`False`, pembongkaran menggunakan PyTorch implementasi asli. Jika`True`, ia menggunakan implementasi offloading aktivasi SMP. Anda juga perlu menggunakan PyTorch aktivasi offload wrapper (`torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper`) di skrip Anda. Untuk mempelajari selengkapnya, lihat [Pelepasan aktivasi](model-parallel-core-features-v2-pytorch-activation-offloading.md). Nilai default-nya adalah `True`. + `activation_loading_horizon`(Integer) — Bilangan bulat yang menentukan tipe horizon offloading aktivasi untuk FSDP. Ini adalah jumlah maksimum lapisan yang diperiksa atau diturunkan yang inputnya dapat berada di memori GPU secara bersamaan. Untuk mempelajari selengkapnya, lihat [Pelepasan aktivasi](model-parallel-core-features-v2-pytorch-activation-offloading.md). Nilai input harus berupa bilangan bulat positif. Nilai default-nya adalah `2`. + `fsdp_cache_flush_warnings`(Boolean) — Mendeteksi dan memperingatkan jika pemisahan cache terjadi di pengelola PyTorch memori, karena dapat menurunkan kinerja komputasi. Nilai default-nya adalah `True`. + `allow_empty_shards`(Boolean) — Apakah akan mengizinkan pecahan kosong saat memecah tensor jika tensor tidak dapat dibagi. Ini adalah perbaikan eksperimental untuk crash selama checkpointing dalam skenario tertentu. Menonaktifkan ini kembali ke PyTorch perilaku aslinya. Nilai default-nya adalah `False`. + `tensor_parallel_degree`(Integer) — Menentukan derajat paralelisme tensor. Nilainya 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 [`obor.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 derajat 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 [`obor.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 [`obor.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 ahli paralel untuk menetapkan benih aktual untuk setiap peringkat. Ini unik untuk setiap peringkat tensor-paralel dan ahli paralel. SMP v2 memastikan bahwa bilangan acak yang dihasilkan di peringkat tensor-paralel dan pakar-paralel masing-masing cocok dengan kasus paralelisme non-tensor-dan paralelisme non-ahli. ## Referensi untuk paket SMP v2 `tor` ch.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) + [`obor.sagemaker.distributed.checkpoint.state_dict_saver.save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-save) + [`obor.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) + [`obor.sagemaker.nn.attn. FlashSelfAttention`](#model-parallel-v2-torch-sagemaker-reference-flashselfattention) + [`obor.sagemaker.nn.attn. FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) + [`obor.sagemaker.nn.huggingface.llama_flashattn. LlamaFlashAttention`](#model-parallel-v2-torch-sagemaker-reference-llamaFlashAttn) + [`obor.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) + [`fungsi dan properti util torch.sagemaker`](#model-parallel-v2-torch-sagemaker-reference-utils) ### `torch.sagemaker.delayed_param. DelayedParamIniter` API untuk menerapkan [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 dari SMP v2. + `init_method_using_config`(Dapat dipanggil) - Jika Anda menggunakan implementasi paralel tensor dari 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 SM `DelayedParamIniter` P. ``` 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[`fungsi dan properti util torch.sagemaker`](#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 lewati ke `param_init_fn` argumen kelas pembungkus PyTorch FSDP. + `get_post_param_init_fn()`— Mengembalikan fungsi inisialisasi parameter yang dapat Anda lewati ke `post_param_init_fn` argumen kelas pembungkus PyTorch FSDP. Ini diperlukan ketika Anda telah mengikat beban dalam model. Model harus menerapkan metode tersebut`tie_weights`. Untuk informasi lebih lanjut, lihat ** Catatan tentang berat terikat ** di[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 `validate_params_and_buffers_inited` metode secara implisit memanggil metode ini di backend. + `validate_params_and_buffers_inited`(`enabled: bool=True`) — Ini adalah pengelola 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 meningkat `AssertionErrors` jika kondisi ini tidak terpenuhi. Manajer konteks ini hanya opsional dan Anda tidak diharuskan menggunakan pengelola konteks ini untuk menginisialisasi parameter. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save` API entri untuk penyimpanan asinkron. Gunakan metode ini untuk menyimpan `state_dict` secara 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. Diktat negara untuk menabung. + `checkpoint_id`(str) - Diperlukan. Jalur penyimpanan untuk menyimpan pos pemeriksaan. + `storage_writer`(StorageWriter) - Opsional. Contoh [`StorageWriter`](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter) in PyTorch untuk melakukan operasi tulis. Jika ini tidak ditentukan, konfigurasi default [`StorageWriter`](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter) digunakan. + `planner`(SavePlanner) - Opsional. Contoh [`SavePlanner`](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner) di PyTorch. Jika ini tidak ditentukan, konfigurasi default [`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 yang akan 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 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 bucket S3 berada. Jika tidak ditentukan, wilayah tersebut disimpulkan dari`checkpoint_id`. + `s3client_config`(S3ClientConfig) - Opsional. Kelas data yang mengekspos parameter yang dapat dikonfigurasi untuk klien S3. Jika tidak disediakan, konfigurasi default [ S3ClientConfig ](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 dioperasikan. Jika diset `None` el ke, grup proses default (global) digunakan. **Pengembalian ** + Daftar yang berisi indeks panggilan asinkron berhasil diselesaikan. ### `obor.sagemaker.distributed.checkpoint.state_dict_saver.save` Gunakan metode ini untuk menyimpan secara sin `state_dict` kron 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. Diktat negara untuk menabung. + `checkpoint_id`(str) - Diperlukan. Jalur penyimpanan untuk menyimpan pos pemeriksaan. + `storage_writer`(StorageWriter) - Opsional. Contoh [`StorageWriter`](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter) in PyTorch untuk melakukan operasi tulis. Jika ini tidak ditentukan, konfigurasi default [`StorageWriter`](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter) digunakan. + `planner`(SavePlanner) - Opsional. Contoh [`SavePlanner`](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner) di PyTorch. Jika ini tidak ditentukan, konfigurasi default [`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 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 bucket S3 berada. Jika tidak ditentukan, wilayah tersebut disimpulkan dari`checkpoint_id`. + `s3client_config`(S3ClientConfig) - Opsional. Kelas data yang mengekspos parameter yang dapat dikonfigurasi untuk klien S3. Jika tidak disediakan, konfigurasi default [ S3ClientConfig ](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. ### `obor.sagemaker.distributed.checkpoint.state_dict_loader.load` Muat kamus status 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. Untuk `state_dict` memuat. + `checkpoint_id`(str) - Diperlukan. ID pos pemeriksaan. Arti `checkpoint_id` tergantung pada penyimpanan. Ini bisa menjadi jalur ke folder atau ke file. Ini juga bisa menjadi kunci jika penyimpanan adalah penyimpanan nilai kunci. + `storage_reader`(StorageReader) - Opsional. Contoh [`StorageReader`](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader) in PyTorch untuk melakukan operasi baca. Jika tidak ditentukan, checkpointing terdistribusi akan secara otomatis menyimpulkan pembaca berdasarkan. `checkpoint_id` Jika `checkpoint_id` juga`None`, kesalahan pengecualian muncul. + `planner`(StorageReader) - Opsional. Contoh [`LoadPlanner`](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner) di PyTorch. Jika tidak ditentukan, konfigurasi default [`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 bucket S3 berada. Jika tidak ditentukan, wilayah tersebut disimpulkan dari`checkpoint_id`. + `s3client_config`(S3ClientConfig) - Opsional. Kelas data yang mengekspos parameter yang dapat dikonfigurasi untuk klien S3. Jika tidak disediakan, konfigurasi default [ S3ClientConfig ](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` Kelas konfigurasi untuk mengatur Mixture-of-Experts (MoE). SMP-implementation Anda dapat menentukan nilai konfigurasi MoE melalui kelas ini dan meneruskannya ke panggilan [`torch.sagemaker.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 MoE SMP-implementation . 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 penyeimbangan beban router MoE. Opsi yang valid adalah`aux_loss`,`sinkhorn`,`balanced`, dan`none`. Nilai default-nya adalah `sinkhorn`. + `global_token_shuffle`(Boolean) - Apakah akan mengocokkan token di seluruh peringkat EP dalam grup EP yang sama. Nilai default-nya adalah `False`. + `moe_all_to_all_dispatcher`(Boolean) - Apakah akan menggunakan operator all-to-all 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`. ### `obor.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 dilewati, faktor skala ini diterapkan untuk softmax. Jika diset `None` el ke (yang juga merupakan nilai default), faktor skalanya adalah`1 / sqrt(attention_head_size)`. Nilai default-nya adalah `None`. + `triton_flash_attention`(bool) — Jika dilewati, implementasi perhatian flash Triton digunakan. Ini diperlukan untuk mendukung Perhatian dengan Bias Linear (ALiBi) (lihat `use_alibi` parameter berikut). Versi kernel ini tidak mendukung dropout. Nilai default-nya adalah `False`. + `use_alibi`(bool) — Jika dilewatkan, ini mengaktifkan Attention with Linear Biases (ALiBi) menggunakan topeng yang disediakan. Saat menggunakan ALiBi, 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 dilewatkan 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 diset `False` el ke, yang merupakan nilai default argumen, tidak ada topeng yang diterapkan. Saat diatur ke`True`, `forward` metode ini menggunakan topeng segitiga bawah standar. Nilai default-nya adalah `False`. + `cast_dtype`— Ketika diatur ke tertentu`dtype`, ia melemparkan `qkv` tensor ke yang `dtype` sebelumnya`attn`. Ini berguna untuk implementasi seperti GPT-NeoX model Hugging Face Transformer, yang memiliki `q` dan `k` dengan penyematan putar `fp32` setelah. Jika disetel ke`None`, tidak ada cast 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 dilewatkan, sehingga transformasi yang sesuai dapat diterapkan. `attn` Nilai default-nya adalah `b h s d`. **Pengembalian ** Satu `torch.Tensor` dengan bentuk`(batch_size x num_heads x seq_len x head_size)`. ### `obor.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 dikelompokkan](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 dilewati, faktor skala ini diterapkan untuk softmax. Jika diset `None` el ke, `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 bentuk. + `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 diset `False` el ke, yang merupakan nilai default argumen, tidak ada topeng yang diterapkan. Saat diatur ke`True`, `forward` metode ini menggunakan topeng segitiga bawah standar. Nilai default-nya adalah `False`. + `cast_dtype`— Ketika diatur ke dtype tertentu, ia melemparkan `qkv` tensor ke dtype sebelumnya. `attn` Ini berguna untuk implementasi seperti Hugging Face Transformers GPT-NeoX, yang memiliki penyematan `q,k` `fp32` setelah putar. Jika disetel ke`None`, tidak ada cast 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 dilewatkan, sehingga transformasi yang sesuai 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. ### `obor.sagemaker.nn.huggingface.llama_flashattn. LlamaFlashAttention` API yang mendukung FlashAttention model Llama. API ini menggunakan [`obor.sagemaker.nn.attn. FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) API di level rendah. Untuk mempelajari cara menggunakan ini, lihat[Gunakan FlashAttention kernel untuk perhatian kueri yang dikelompokkan](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` ada, itu dalam bentuk`(batch_size x seqlen)`, menunjukkan indeks posisi setiap token urutan input dalam penyematan posisi. Nilai default-nya adalah `None`. + `past_key_value`(Cache) — Pre-computed keadaan tersembunyi (kunci dan nilai dalam 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 `past_key_values` status nilai 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. ### `obor.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 dilewati, 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 manajer konteks dtype untuk pembuatan model dan membuat model dengan dtype ini. Ini biasanya tidak perlu, karena kita ingin membuat model `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 model dengan bobot baru. Ketika argumen ini diset `True` el ke, SMP mencoba memuat kamus keadaan PyTorch model asli dari peringkat 0 ke dalam model yang diubah untuk grup paralel tensor yang merupakan bagiannya peringkat 0. Ketika ini disetel ke`True`, peringkat 0 tidak dapat memiliki parameter apa pun di perangkat meta. Hanya kelompok paralel tensor pertama yang mengisi bobot dari peringkat 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, pustaka SMP memuat kamus status dari model asli. Pustaka SMP mengambil model sebelum transform `state_dict` asi, mengubahnya agar sesuai dengan struktur model yang diubah, memecahnya untuk setiap peringkat paralel tensor, mengkomunikasikan keadaan ini dari peringkat 0 ke peringkat lain dalam kelompok paralel tensor yang merupakan bagian dari peringkat 0, dan memuatnya. Nilai default-nya adalah `False`. + `cp_comm_type`(str) — Menentukan implementasi paralelisme konteks dan hanya berlaku jika `context_parallel_degree` lebih besar dari 1. Nilai yang tersedia untuk parameter ini adalah `p2p` dan`all_gather`. `p2p`Implementasi menggunakan panggilan kirim-terima peer-to-peer untuk akumulasi tensor kunci-dan-nilai (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. Ketika `load_state_dict_from_rank0` disetel ke`True`, grup paralel tensor yang melibatkan peringkat 0 memiliki bobot yang dimuat dari kamus keadaan 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 pada CPU untuk parameter dan buffer dari model yang diubah. Sisa peringkat terus memiliki parameter dan buffer pada perangkat meta untuk menghemat memori. ### `fungsi dan properti util torch.sagemaker` **fungsi util torch.sagemaker** + `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. Saat kembali ke native PyTorch saat pekerjaan diinisialisasi dengan SMP, beberapa properti tidak relevan dan menjadi`None`, seperti yang ditunjukkan dalam daftar Properties 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 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 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 terpecah-pecah, 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 tetapi mendasar dengan`torch.sagemaker.state.tp_process_group`. Ketika kembali ke asli PyTorch, itu kembali`None`. + `torch.sagemaker.state.tensor_parallel_degree`(int) — Tingkat 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) — 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 terpecah-pecah) tetapi peringkat paralel tensor yang unik. Ketika kembali ke asli PyTorch, itu kembali`None`. + `torch.sagemaker.state.world_size`(int) — Jumlah total perangkat yang digunakan dalam pelatihan. ## Tingkatkan dari SMP v1 ke SMP v2 Untuk pindah dari SMP v1 ke SMP v2, Anda harus membuat perubahan skrip untuk menghapus API SMP v1 dan menerapkan API SMP v2. Alih-alih memulai dari skrip SMP v1 Anda, kami sarankan Anda memulai dari skri PyTorch p 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 di[Pemeriksaan menggunakan SMP](model-parallel-core-features-v2-checkpoints.md), Anda dapat memuat pos pemeriksaan model Hugging Face Transformers, dan kemudian melanjutkan dengan menggunakan API PyTorch pos pemeriksaan dengan SMP v2. 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[Dukungan untuk Model Transformer Wajah Memeluk](model-parallel-extended-features-pytorch-hugging-face.md). Untuk instruksi tentang penyimpanan dan pemuatan pos pemeriksaan model di SMP v2, lihat. [Pemeriksaan menggunakan SMP](model-parallel-core-features-v2-checkpoints.md)