Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# PyTorch
Bawa PyTorch model Anda sendiri ke SageMaker AI, dan jalankan pekerjaan pelatihan dengan Tra SageMaker ining Compiler.
**Topics**
+ [PyTorch Model dengan Transformer Wajah Pelukan](#training-compiler-pytorch-models-transformers)
## PyTorch Model dengan Transformer Wajah Pelukan
PyTorch model dengan [ Hugging Face Transformers ](https://huggingface.co/docs/transformers/index) didasarkan pada API [ Torch ](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) .n PyTorch n.Module. Hugging Face Transformers juga menyediakan [ Trainer ](https://huggingface.co/docs/transformers/main_classes/trainer) dan kelas model yang telah dilatih sebelumnya PyTorch untuk membantu mengurangi upaya mengonfigurasi model pemrosesan bahasa alami (NLP). Setelah menyiapkan skrip pelatihan Anda, Anda dapat meluncurkan pekerjaan pelatihan menggunakan SageMaker AI `PyTorch` atau `HuggingFace` ModelTrainer dengan konfigurasi Kompiler Pelatihan ketika Anda akan melanjutkan ke topik berikutnya di[Aktifkan Kom SageMaker piler Pelatihan](training-compiler-enable.md). SageMaker
**Tip**
Saat Anda membuat tokenizer untuk model NLP menggunakan Transformers dalam skrip pelatihan Anda, pastikan Anda menggunakan bentuk tensor input statis dengan menentukan. `padding='max_length'` Jangan gunakan `padding='longest'` karena bantalan ke urutan terpanjang dalam batch dapat mengubah bentuk tensor untuk setiap batch pelatihan. Bentuk input dinamis dapat memicu kompilasi ulang model dan mungkin meningkatkan total waktu pelatihan. Untuk informasi selengkapnya tentang opsi padding dari tokenizer Transformers, lihat [ Padding dan truncation ](https://huggingface.co/docs/transformers/pad_truncation) di dokumentasi Hugging Face Transformers. * *
**Topics**
+ [Model Bahasa Besar Menggunakan Kelas Pel `atih` Hugging Face Transformers](#training-compiler-pytorch-models-transformers-trainer)
+ [Model Bahasa Besar Menggunakan Lang PyTorch sung (tanpa API Hugging Face Transformers Trainer)](#training-compiler-pytorch-models-non-trainer)
### Model Bahasa Besar Menggunakan Kelas Pel `atih` Hugging Face Transformers
Jika Anda menggunakan kelas Trainer library transformer, Anda tidak perlu membuat perubahan tambahan pada skrip pelatihan Anda. SageMaker Training Compiler secara otomatis mengkompilasi model Trainer Anda jika Anda mengaktifkannya melalui kelas. ModelTrainer Kode berikut menunjukkan bentuk dasar skrip PyTorch pelatihan dengan Hugging Face Trainer API.
```
from transformers import Trainer, TrainingArguments
training_args=TrainingArguments(**kwargs)
trainer=Trainer(args=training_args, **kwargs)
```
**Topics**
+ [Untuk pelatihan GPU tunggal](#training-compiler-pytorch-models-transformers-trainer-single-gpu)
+ [Untuk pelatihan terdistribusi](#training-compiler-pytorch-models-transformers-trainer-distributed)
+ [Praktik Terbaik untuk Menggunakan Kompiler Pel SageMaker atihan dengan Pelatih ``](#training-compiler-pytorch-models-transformers-trainer-best-practices)
#### Untuk pelatihan GPU tunggal
Anda tidak perlu mengubah kode Anda saat menggunakan [`transformers.Trainer`](https://huggingface.co/docs/transformers/main_classes/trainer) kelas.
#### Untuk pelatihan terdistribusi
**PyTorch v1.11.0 dan yang lebih baru **
Untuk menjalankan pelatihan terdistribusi dengan SageMaker Training Compiler, Anda harus menambahkan `_mp_fn()` fungsi berikut dalam skrip pelatihan Anda dan membungkus `main()` fungsi tersebut. Ini mengalihkan panggilan `_mp_fn(index)` fungsi dari runtime ter SageMaker distribusi AI untuk PyTorch (`pytorchxla`) ke `main()` fungsi skrip pelatihan Anda.
```
def _mp_fn(index):
main()
```
Fungsi ini menerima `index` argumen untuk menunjukkan peringkat GPU saat ini di cluster untuk pelatihan terdistribusi. Untuk menemukan lebih banyak contoh skrip, lihat skri [ p contoh pemodelan bahasa ](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling) Hugging Face Transformers.
**Untuk Transformers v4.17 dan sebelumnya dengan PyTorch v1.10.2 dan sebelumnya **
SageMaker Training Compiler menggunakan mekanisme alternatif untuk meluncurkan pekerjaan pelatihan terdistribusi, dan Anda tidak perlu melakukan modifikasi apa pun dalam skrip pelatihan Anda. Sebagai gantinya, Tra SageMaker ining Compiler mengharuskan Anda untuk mener SageMaker uskan skrip peluncur pelatihan terdistribusi AI ke `entry_point` argumen dan meneruskan skrip pelatihan Anda ke `hyperparameters` argumen di SageMaker AI Hugging Face. ModelTrainer
#### Praktik Terbaik untuk Menggunakan Kompiler Pel SageMaker atihan dengan Pelatih ``
+ Pastikan Anda menggunakan pengoptimal SyncFree dengan menyetel `optim` argumen ke `adamw_torch_xla` saat menyiapkan [ transformer. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments). Lihat juga Peng [ optimal ](https://huggingface.co/docs/transformers/v4.23.1/en/perf_train_gpu_one#optimizer) dalam dokumentasi * Hugging Face Transformers. *
+ Pastikan throughput pipeline pemrosesan data lebih tinggi dari throughput pelatihan. Anda dapat mengubah `preprocessing_num_workers` argum `dataloader_num_workers` en dan dari [ transformer. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments)kelas untuk mencapai hal ini. Biasanya, ini harus lebih besar dari atau sama dengan jumlah GPU tetapi kurang dari jumlah CPU.
Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan ke[Jalan PyTorch kan Pekerjaan Pelatihan dengan Tra SageMaker ining Compiler](training-compiler-enable-pytorch.md).
### Model Bahasa Besar Menggunakan Lang PyTorch sung (tanpa API Hugging Face Transformers Trainer)
Jika Anda memiliki skrip pelatihan yang digunakan PyTorch secara langsung, Anda perlu membuat perubahan tambahan pada skrip PyTorch pelatihan Anda untuk diterapkan PyTorch/XLA. Ikuti instruksi untuk memodifikasi skrip Anda untuk mengatur PyTorch/XLA primatif dengan benar.
**Topics**
+ [Untuk pelatihan GPU tunggal](#training-compiler-pytorch-models-non-trainer-single-gpu)
+ [Untuk pelatihan terdistribusi](#training-compiler-pytorch-models-non-trainer-distributed)
+ [Praktik Terbaik untuk Menggunakan Kompiler Pel SageMaker atihan dengan PyTorch/XLA](#training-compiler-pytorch-models-best-practices)
#### Untuk pelatihan GPU tunggal
1. Impor pustaka pengoptimalan.
```
import torch_xla
import torch_xla.core.xla_model as xm
```
1. Ubah perangkat target menjadi XLA alih-alih `torch.device("cuda")`
```
device=xm.xla_device()
```
1. Jika Anda menggunakan [ Automatic PyTorch Mixed Precision ](https://pytorch.org/docs/stable/amp.html) (AMP), lakukan hal berikut:
1. Ganti `torch.cuda.amp` dengan yang berikut:
```
import torch_xla.amp
```
1. Ganti `torch.optim.SGD` dan `torch.optim.Adam` dengan yang berikut:
```
import torch_xla.amp.syncfree.Adam as adam
import torch_xla.amp.syncfree.SGD as SGD
```
1. Ganti `torch.cuda.amp.GradScaler` dengan yang berikut:
```
import torch_xla.amp.GradScaler as grad_scaler
```
1. Jika Anda tidak menggunakan AMP, ganti `optimizer.step()` dengan yang berikut ini:
```
xm.optimizer_step(optimizer)
```
1. Jika Anda menggunakan pemuat data terdistribusi, bungkus dataloader Anda di kelasnya: PyTorch/XLA `ParallelLoader`
```
import torch_xla.distributed.parallel_loader as pl
parallel_loader=pl.ParallelLoader(dataloader, [device]).per_device_loader(device)
```
1. Tambahkan `mark_step` di akhir loop pelatihan saat Anda tidak menggunakan`parallel_loader`:
```
xm.mark_step()
```
1. Untuk memeriksa pelatihan Anda, gunakan metode PyTorch/XLA pos pemeriksaan model:
```
xm.save(model.state_dict(), path_to_save)
```
Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan ke[Jalan PyTorch kan Pekerjaan Pelatihan dengan Tra SageMaker ining Compiler](training-compiler-enable-pytorch.md).
#### Untuk pelatihan terdistribusi
Selain perubahan yang tercantum di [Untuk pelatihan GPU tunggal](#training-compiler-pytorch-models-non-trainer-single-gpu) bagian sebelumnya, tambahkan perubahan berikut untuk mendistribusikan beban kerja dengan benar di seluruh GPU.
1. Jika Anda menggunakan AMP, tambahkan `all_reduce` setelah`scaler.scale(loss).backward()`:
```
gradients=xm._fetch_gradients(optimizer)
xm.all_reduce('sum', gradients, scale=1.0/xm.xrt_world_size())
```
1. Jika Anda perlu mengatur variabel untuk `local_ranks` dan`world_size`, gunakan kode serupa dengan yang berikut ini:
```
local_rank=xm.get_local_ordinal()
world_size=xm.xrt_world_size()
```
1. Untuk setiap `world_size` (`num_gpus_per_node*num_nodes`) yang lebih besar dari`1`, Anda harus menentukan sampler kereta yang akan terlihat mirip dengan berikut ini:
```
import torch_xla.core.xla_model as xm
if xm.xrt_world_size() > 1:
train_sampler=torch.utils.data.distributed.DistributedSampler(
train_dataset,
num_replicas=xm.xrt_world_size(),
rank=xm.get_ordinal(),
shuffle=True
)
train_loader=torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
sampler=train_sampler,
drop_last=args.drop_last,
shuffle=False if train_sampler else True,
num_workers=args.num_workers
)
```
1. Buat perubahan berikut untuk memastikan Anda menggunakan yang `parallel_loader` disediakan oleh `torch_xla distributed` modul.
```
import torch_xla.distributed.parallel_loader as pl
train_device_loader=pl.MpDeviceLoader(train_loader, device)
```
`train_device_loader`Fungsi seperti PyTorch loader biasa sebagai berikut:
```
for step, (data, target) in enumerate(train_device_loader):
optimizer.zero_grad()
output=model(data)
loss=torch.nn.NLLLoss(output, target)
loss.backward()
```
Dengan semua perubahan ini, Anda harus dapat meluncurkan pelatihan terdistribusi dengan PyTorch model apa pun tanpa Transformer Trainer API. Perhatikan bahwa instruksi ini dapat digunakan untuk multi-GPU single-node dan multi-node multi-GPU.
1. **Untuk PyTorch v1.11.0 dan yang lebih baru **
Untuk menjalankan pelatihan terdistribusi dengan SageMaker Training Compiler, Anda harus menambahkan `_mp_fn()` fungsi berikut dalam skrip pelatihan Anda dan membungkus `main()` fungsi tersebut. Ini mengalihkan panggilan `_mp_fn(index)` fungsi dari runtime ter SageMaker distribusi AI untuk PyTorch (`pytorchxla`) ke `main()` fungsi skrip pelatihan Anda.
```
def _mp_fn(index):
main()
```
Fungsi ini menerima `index` argumen untuk menunjukkan peringkat GPU saat ini di cluster untuk pelatihan terdistribusi. Untuk menemukan lebih banyak contoh skrip, lihat skri [ p contoh pemodelan bahasa ](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling) Hugging Face Transformers.
**Untuk Transformers v4.17 dan sebelumnya dengan PyTorch v1.10.2 dan sebelumnya **
SageMaker Training Compiler menggunakan mekanisme alternatif untuk meluncurkan pekerjaan pelatihan terdistribusi dan mengharuskan Anda untuk meneruskan skrip peluncur pelatihan terdistribusi SageMaker AI ke `entry_point` argumen dan meneruskan skrip pelatihan Anda ke `hyperparameters` argumen di SageMaker AI Hugging Face. ModelTrainer
Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan ke[Jalan PyTorch kan Pekerjaan Pelatihan dengan Tra SageMaker ining Compiler](training-compiler-enable-pytorch.md).
#### Praktik Terbaik untuk Menggunakan Kompiler Pel SageMaker atihan dengan PyTorch/XLA
Jika Anda ingin memanfaatkan Kompiler SageMaker Pelatihan pada skrip PyTorch pelatihan asli Anda, Anda mungkin ingin membiasakan diri terlebih dahulu [ PyTorch di perangkat XLA. ](https://pytorch.org/xla/release/1.9/index.html) Bagian berikut mencantumkan beberapa praktik terbaik untuk mengaktifkan XLA untuk PyTorch.
**catatan**
Bagian ini untuk praktik terbaik mengasumsikan bahwa Anda menggunakan PyTorch/XLA modul berikut:
```
import torch_xla.core.xla_model as xm
import torch_xla.distributed.parallel_loader as pl
```
##### Pahami mode malas di PyTorch/XLA
Satu perbedaan signifikan antara PyTorch/XLA dan asli PyTorch adalah bahwa PyTorch/XLA sistem berjalan dalam mode malas sementara yang asli PyTorch berjalan dalam mode penasaran. Tensor dalam mode malas adalah placeholder untuk membangun grafik komputasi sampai terwujud setelah kompilasi dan evaluasi selesai. PyTorch/XLA Sistem membangun grafik komputasi dengan cepat ketika Anda memanggil PyTorch API untuk membangun komputasi menggunakan tensor dan operator. Grafik komputasi dikompilasi dan dieksekusi ketika `xm.mark_step()` dipanggil secara eksplisit atau implisit oleh`pl.MpDeviceLoader/pl.ParallelLoader`, atau ketika Anda secara eksplisit meminta nilai tensor seperti dengan memanggil `loss.item()` atau. `print(loss)`
##### Minimalkan jumlah *kompilasi-dan-eksekusi* menggunakan `pl. MpDeviceLoader/pl.ParallelLoader`dan `xm.step_close`
Untuk kinerja terbaik, Anda harus mengingat cara yang mungkin untuk memulai * kompilasi-dan-eksekusi * seperti yang dijelaskan di [Pahami mode malas di PyTorch/XLA](#training-compiler-pytorch-models-best-practices-lazy-mode) dan harus mencoba meminimalkan jumlah kompilasi-dan-eksekusi. Idealnya, hanya satu kompilasi-dan-eksekusi yang diperlukan per iterasi pelatihan dan dimulai secara otomatis oleh. `pl.MpDeviceLoader/pl.ParallelLoader` Di `MpDeviceLoader` optimalkan untuk XLA dan harus selalu digunakan jika memungkinkan untuk kinerja terbaik. Selama pelatihan, Anda mungkin ingin memeriksa beberapa hasil menengah seperti nilai kerugian. Dalam kasus seperti itu, pencetakan tensor malas harus dibungkus menggunakan `xm.add_step_closure()` untuk menghindari kompilasi dan eksekusi yang tidak perlu.
##### Gunakan pengoptimal AMP dan `sinkronisasi`
Pelatihan dalam mode Automatic Mixed Precision (AMP) secara signifikan mempercepat kecepatan latihan Anda dengan memanfaatkan inti Tensor GPU NVIDIA. SageMaker Training Compiler menyediakan `syncfree` pengoptimal yang dioptimalkan untuk XLA untuk meningkatkan kinerja AMP. Saat ini, tiga peng `syncfree` optimal berikut tersedia dan harus digunakan jika memungkinkan untuk kinerja terbaik.
```
torch_xla.amp.syncfree.SGD
torch_xla.amp.syncfree.Adam
torch_xla.amp.syncfree.AdamW
```
Pengoptimal `syncfree` ini harus dipasangkan dengan `torch_xla.amp.GradScaler` untuk gradien scaling/unscaling.
**Tip**
Mulai PyTorch 1.13.1, Tra SageMaker ining Compiler meningkatkan kinerja dengan PyTorch/XLA membiarkan pengoptimal secara otomatis mengganti (seperti SGD, Adam, AdamW) di dalam `torch.optim` atau `transformers.optimization` dengan versi sinkfree di (seperti,,). `torch_xla.amp.syncfree` `torch_xla.amp.syncfree.SGD` `torch_xla.amp.syncfree.Adam` `torch_xla.amp.syncfree.AdamW` Anda tidak perlu mengubah baris kode tempat Anda menentukan pengoptimal dalam skrip pelatihan Anda.