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 SageMaker Training Compiler.
**Topics**
+ [PyTorch Model dengan Trafo Hugging Face](#training-compiler-pytorch-models-transformers)
## PyTorch Model dengan Trafo Hugging Face
PyTorch [model dengan [Hugging Face](https://huggingface.co/docs/transformers/index) Transformers didasarkan PyTorch pada API torch.nn.Module.](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) Hugging Face Transformers juga [menyediakan](https://huggingface.co/docs/transformers/main_classes/trainer) kelas Trainer dan model terlatih PyTorch untuk membantu mengurangi upaya mengonfigurasi model pemrosesan bahasa alami (NLP). Setelah menyiapkan skrip pelatihan, Anda dapat meluncurkan pekerjaan pelatihan menggunakan SageMaker AI `PyTorch` atau `HuggingFace` estimator dengan konfigurasi SageMaker Training Compiler saat Anda akan melanjutkan ke topik berikutnya di. [Aktifkan Kompiler SageMaker Pelatihan](training-compiler-enable.md)
**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 padding ke urutan terpanjang dalam batch dapat mengubah bentuk tensor untuk setiap batch pelatihan. Bentuk input dinamis dapat memicu kompilasi ulang model dan dapat meningkatkan total waktu pelatihan. *Untuk informasi selengkapnya tentang opsi padding tokenizer Transformers, lihat [Padding dan pemotongan dalam dokumentasi Hugging Face Transformers.](https://huggingface.co/docs/transformers/pad_truncation)*
**Topics**
+ [Model Bahasa Besar Menggunakan Kelas Hugging Face Transformers `Trainer`](#training-compiler-pytorch-models-transformers-trainer)
+ [Model Bahasa Besar Menggunakan PyTorch Langsung (tanpa API Pelatih Trainer Hugging Face Transformers)](#training-compiler-pytorch-models-non-trainer)
### Model Bahasa Besar Menggunakan Kelas Hugging Face Transformers `Trainer`
Jika Anda menggunakan kelas Trainer perpustakaan transformer, Anda tidak perlu membuat perubahan tambahan pada skrip pelatihan Anda. SageMaker Training Compiler secara otomatis mengompilasi model Trainer Anda jika Anda mengaktifkannya melalui class estimator. 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 SageMaker Pelatihan dengan `Trainer`](#training-compiler-pytorch-models-transformers-trainer-best-practices)
#### Untuk pelatihan GPU tunggal
Anda tidak perlu mengubah kode Anda saat menggunakan [https://huggingface.co/docs/transformers/main_classes/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()` fungsinya. Ini mengalihkan panggilan `_mp_fn(index)` fungsi dari runtime terdistribusi SageMaker AI for 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 skrip contoh [pemodelan bahasa Hugging Face Transformers](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling).
**Untuk Transformers v4.17 dan sebelumnya dengan v1.10.2 dan sebelumnya PyTorch **
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, SageMaker Training Compiler mengharuskan Anda untuk meneruskan skrip peluncur pelatihan terdistribusi SageMaker AI ke `entry_point` argumen dan meneruskan skrip pelatihan Anda ke `hyperparameters` argumen di penaksir SageMaker AI Hugging Face.
#### Praktik Terbaik untuk Menggunakan Kompiler SageMaker Pelatihan dengan `Trainer`
+ [Pastikan Anda menggunakan SyncFree pengoptimal dengan menyetel `optim` argumen `adamw_torch_xla` saat menyiapkan transformer. TrainingArgument](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments). Lihat juga [Optimizer](https://huggingface.co/docs/transformers/v4.23.1/en/perf_train_gpu_one#optimizer) dalam dokumentasi *Hugging Face* Transformers.
+ Pastikan bahwa throughput pipa pemrosesan data lebih tinggi daripada throughput pelatihan. Anda dapat men-tweak `dataloader_num_workers` dan `preprocessing_num_workers` argumen 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 GPUs tetapi kurang dari jumlah CPUs.
Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan ke[Jalankan Pekerjaan PyTorch Pelatihan dengan Kompiler SageMaker Pelatihan](training-compiler-enable-pytorch.md).
### Model Bahasa Besar Menggunakan PyTorch Langsung (tanpa API Pelatih Trainer Hugging Face Transformers)
Jika Anda memiliki skrip pelatihan yang menggunakan PyTorch secara langsung, Anda perlu membuat perubahan tambahan pada skrip PyTorch pelatihan Anda untuk mengimplementasikan PyTorch /XLA. Ikuti petunjuk untuk memodifikasi skrip Anda untuk mengatur primatif PyTorch /XLA 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 SageMaker Pelatihan dengan/XLA PyTorch](#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 PyTorch [Automatic Mixed Precision](https://pytorch.org/docs/stable/amp.html) (AMP), lakukan hal berikut:
1. Ganti `torch.cuda.amp` dengan yang berikut ini:
```
import torch_xla.amp
```
1. Ganti `torch.optim.SGD` dan `torch.optim.Adam` dengan yang berikut ini:
```
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 ini:
```
import torch_xla.amp.GradScaler as grad_scaler
```
1. Jika Anda tidak menggunakan AMP, ganti `optimizer.step()` dengan yang berikut:
```
xm.optimizer_step(optimizer)
```
1. Jika Anda menggunakan dataloader terdistribusi, bungkus dataloader Anda di kelas /XLA: PyTorch `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 pos pemeriksaan PyTorch model/XLA:
```
xm.save(model.state_dict(), path_to_save)
```
Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan ke[Jalankan Pekerjaan PyTorch Pelatihan dengan Kompiler SageMaker Pelatihan](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 GPUs beban kerja dengan benar.
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 yang mirip 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-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 simpul tunggal 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()` fungsinya. Ini mengalihkan panggilan `_mp_fn(index)` fungsi dari runtime terdistribusi SageMaker AI for 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 skrip contoh [pemodelan bahasa Hugging Face Transformers](https://github.com/huggingface/transformers/blob/v4.21.1/examples/pytorch/language-modeling).
**Untuk Transformers v4.17 dan sebelumnya dengan v1.10.2 dan sebelumnya PyTorch**
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 penaksir SageMaker AI Hugging Face.
Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan ke[Jalankan Pekerjaan PyTorch Pelatihan dengan Kompiler SageMaker Pelatihan](training-compiler-enable-pytorch.md).
#### Praktik Terbaik untuk Menggunakan Kompiler SageMaker Pelatihan dengan/XLA PyTorch
Jika Anda ingin memanfaatkan SageMaker Training Compiler pada skrip PyTorch pelatihan asli Anda, Anda mungkin ingin terlebih dahulu mengenal [PyTorch perangkat XLA](https://pytorch.org/xla/release/1.9/index.html). Bagian berikut mencantumkan beberapa praktik terbaik untuk mengaktifkan XLA. 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
```
##### Memahami mode malas PyTorch di/XLA
Satu perbedaan signifikan antara PyTorch/XLA dan native PyTorch adalah bahwa PyTorch/XLA sistem berjalan dalam mode malas sementara native PyTorch berjalan dalam mode bersemangat. Tensor dalam mode malas adalah placeholder untuk membangun grafik komputasi hingga terwujud setelah kompilasi dan evaluasi selesai. PyTorch/XLA Sistem membangun grafik komputasi dengan cepat saat Anda menelepon PyTorch APIs 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 atau. `loss.item()` `print(loss)`
##### Minimalkan jumlah *compilation-and-executions*penggunaan `pl.MpDeviceLoader/pl.ParallelLoader` dan `xm.step_closure`
Untuk kinerja terbaik, Anda harus mengingat cara-cara yang mungkin untuk memulai *compilation-and-executions*seperti yang dijelaskan dalam [Memahami mode malas PyTorch di/XLA](#training-compiler-pytorch-models-best-practices-lazy-mode) dan harus mencoba meminimalkan jumlah compilation-and-executions. Idealnya, hanya satu compilation-and-execution yang diperlukan per iterasi pelatihan dan dimulai secara otomatis oleh. `pl.MpDeviceLoader/pl.ParallelLoader` `MpDeviceLoader`Ini dioptimalkan 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 yang tidak perlu. compilation-and-executions
##### Gunakan AMP dan `syncfree` pengoptimal
Pelatihan dalam mode Automatic Mixed Precision (AMP) secara signifikan mempercepat kecepatan latihan Anda dengan memanfaatkan inti Tensor NVIDIA. GPUs SageMaker Training Compiler menyediakan `syncfree` pengoptimal yang dioptimalkan untuk XLA untuk meningkatkan kinerja AMP. Saat ini, tiga `syncfree` pengoptimal 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
```
`syncfree`Pengoptimal ini harus dipasangkan dengan `torch_xla.amp.GradScaler` untuk penskalaan/unscaling gradien.
**Tip**
Mulai PyTorch 1.13.1, SageMaker Training Compiler meningkatkan kinerja dengan membiarkan PyTorch/XLA untuk secara otomatis mengganti pengoptimal (seperti SGD, Adam, AdamW) di dalam `torch.optim` atau `transformers.optimization` dengan versi syncfree dari mereka 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.