PyTorch - Amazon SageMaker
PyTorch Model dengan Trafo Hugging Face

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, dan jalankan pekerjaan pelatihan dengan SageMaker Training Compiler.

PyTorch Model dengan Trafo Hugging Face

PyTorch model dengan Hugging Face Transformers didasarkan PyTorch pada API torch.nn.Module. Hugging Face Transformers juga menyediakan 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 PyTorch atau HuggingFace estimator dengan konfigurasi SageMaker Training Compiler saat Anda akan melanjutkan ke topik berikutnya di. Aktifkan Kompiler SageMaker Pelatihan

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.

Model Bahasa Besar Menggunakan Kelas Hugging Face Transformers Trainer

Jika Anda menggunakan kelas Trainer perpustakaan transformer, Anda tidak perlu membuat perubahan tambahan apa pun 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)

Untuk pelatihan GPU tunggal

Anda tidak perlu mengubah kode Anda saat menggunakan transformers.Trainerkelas.

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 SageMaker terdistribusi 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 skrip contoh pemodelan bahasa Hugging Face Transformers.

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 SageMaker terdistribusi ke entry_point argumen dan meneruskan skrip pelatihan Anda ke hyperparameters argumen di estimator Hugging SageMaker Face.

Praktik Terbaik untuk Menggunakan Kompiler SageMaker Pelatihan dengan Trainer

Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan keJalankan Pekerjaan PyTorch Pelatihan dengan Kompiler SageMaker Pelatihan.

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.

Untuk pelatihan GPU tunggal

  1. Impor pustaka pengoptimalan.

    import torch_xla
import torch_xla.core.xla_model as xm

  2. Ubah perangkat target menjadi XLA alih-alih torch.device("cuda")

    device=xm.xla_device()

  3. Jika Anda menggunakan PyTorch Automatic Mixed Precision (AMP), lakukan hal berikut:

    1. Ganti torch.cuda.amp dengan yang berikut ini:

      import torch_xla.amp

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

    3. Ganti torch.cuda.amp.GradScaler dengan yang berikut ini:

      import torch_xla.amp.GradScaler as grad_scaler

  4. Jika Anda tidak menggunakan AMP, ganti optimizer.step() dengan yang berikut:

    xm.optimizer_step(optimizer)

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

  6. Tambahkan mark_step di akhir loop pelatihan saat Anda tidak menggunakanparallel_loader:

    xm.mark_step()

  7. 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 keJalankan Pekerjaan PyTorch Pelatihan dengan Kompiler SageMaker Pelatihan.

Untuk pelatihan terdistribusi

Selain perubahan yang tercantum di Untuk pelatihan GPU tunggal bagian sebelumnya, tambahkan perubahan berikut untuk mendistribusikan beban kerja dengan benar di seluruh GPU.

  1. Jika Anda menggunakan AMP, tambahkan all_reduce setelahscaler.scale(loss).backward():

    gradients=xm._fetch_gradients(optimizer)
xm.all_reduce('sum', gradients, scale=1.0/xm.xrt_world_size())

  2. Jika Anda perlu mengatur variabel untuk local_ranks danworld_size, gunakan kode yang mirip dengan yang berikut ini:

    local_rank=xm.get_local_ordinal()
world_size=xm.xrt_world_size()

  3. Untuk setiap world_size (num_gpus_per_node*num_nodes) yang lebih besar dari1, 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
)

  4. 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_loaderFungsi-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.

  5. 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 SageMaker terdistribusi 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 skrip contoh pemodelan bahasa Hugging Face Transformers.

    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 SageMaker terdistribusi ke entry_point argumen dan meneruskan skrip pelatihan Anda ke hyperparameters argumen di estimator Hugging SageMaker Face.

Setelah Anda selesai mengadaptasi skrip pelatihan Anda, lanjutkan keJalankan Pekerjaan PyTorch Pelatihan dengan Kompiler SageMaker Pelatihan.

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. Bagian berikut mencantumkan beberapa praktik terbaik untuk mengaktifkan XLA. PyTorch

catatan

Bagian ini untuk praktik terbaik mengasumsikan bahwa Anda menggunakan modul PyTorch /XLA 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 sistem PyTorch /XLA berjalan dalam mode malas sementara native PyTorch berjalan dalam mode eager. Tensor dalam mode malas adalah placeholder untuk membangun grafik komputasi hingga terwujud setelah kompilasi dan evaluasi selesai. Sistem PyTorch /XLA membuat grafik komputasi dengan cepat saat 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 olehpl.MpDeviceLoader/pl.ParallelLoader, atau ketika Anda secara eksplisit meminta nilai tensor seperti dengan memanggil atau. loss.item() print(loss)

Minimalkan jumlah compilation-and-executionspenggunaan pl.MpDeviceLoader/pl.ParallelLoader dan xm.step_closure

Untuk kinerja terbaik, Anda harus mengingat cara-cara yang mungkin untuk memulai compilation-and-executionsseperti yang dijelaskan dalam Memahami mode malas PyTorch di/XLA 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 MpDeviceLoaderIni 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 GPU NVIDIA. 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

syncfreePengoptimal 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 mengganti pengoptimal secara otomatis (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.