Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Bawa Model Pembelajaran Mendalam Anda Sendiri **penting** Amazon Web Services (AWS) mengumumkan bahwa tidak akan ada rilis baru atau versi SageMaker Training Compiler. Anda dapat terus menggunakan SageMaker Training Compiler melalui AWS Deep Learning Containers (DLCs) for SageMaker Training yang ada. Penting untuk dicatat bahwa meskipun yang ada DLCs tetap dapat diakses, mereka tidak akan lagi menerima tambalan atau pembaruan dari AWS, sesuai dengan [Kebijakan Dukungan Framework AWS Deep Learning Containers](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html). Panduan ini memandu Anda melalui cara mengadaptasi skrip pelatihan Anda untuk pekerjaan pelatihan yang dipercepat kompiler. Persiapan skrip pelatihan Anda tergantung pada hal-hal berikut: + Pengaturan pelatihan seperti pelatihan inti tunggal atau terdistribusi. + Kerangka kerja dan pustaka yang Anda gunakan untuk membuat skrip pelatihan. Pilih salah satu topik berikut tergantung pada kerangka kerja yang Anda gunakan. **Topics** + [PyTorch](training-compiler-pytorch-models.md) + [TensorFlow](training-compiler-tensorflow.md) **catatan** Setelah Anda selesai menyiapkan skrip pelatihan Anda, Anda dapat menjalankan pekerjaan SageMaker pelatihan menggunakan kelas estimator kerangka kerja SageMaker AI. Untuk informasi lebih lanjut, lihat topik sebelumnya di[Aktifkan Kompiler SageMaker Pelatihan](training-compiler-enable.md). # 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. # TensorFlow Bawa TensorFlow model Anda sendiri ke SageMaker AI, dan jalankan pekerjaan pelatihan dengan SageMaker Training Compiler. ## TensorFlow Model SageMaker Training Compiler secara otomatis mengoptimalkan beban kerja pelatihan model yang dibangun di atas TensorFlow API asli atau API Keras tingkat tinggi. **Tip** Untuk pra-pemrosesan dataset input Anda, pastikan Anda menggunakan bentuk input statis. Bentuk input dinamis dapat memulai kompilasi ulang model dan dapat meningkatkan total waktu pelatihan. ### Menggunakan Keras (Disarankan) Untuk akselerasi kompiler terbaik, sebaiknya gunakan model yang merupakan subclass dari TensorFlow Keras ([tf.Keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)). #### Untuk pelatihan GPU tunggal Tidak ada perubahan tambahan yang perlu Anda lakukan dalam skrip pelatihan. ### Tanpa Keras SageMaker Training Compiler tidak mendukung eksekusi yang bersemangat di. TensorFlow Oleh karena itu, Anda harus membungkus model dan loop pelatihan Anda dengan TensorFlow fungsi decorator (`@tf.function`) untuk memanfaatkan akselerasi kompiler. SageMaker [Training Compiler melakukan optimasi tingkat grafik, dan menggunakan dekorator untuk memastikan TensorFlow fungsi Anda diatur untuk berjalan dalam mode grafik.](https://www.tensorflow.org/guide/intro_to_graphs) #### Untuk pelatihan GPU tunggal TensorFlow 2.0 atau yang lebih baru memiliki eksekusi bersemangat secara default, jadi Anda harus menambahkan `@tf.function` dekorator di depan setiap fungsi yang Anda gunakan untuk membangun model. TensorFlow ## TensorFlow Model dengan Trafo Hugging Face TensorFlow [model dengan [Hugging Face](https://huggingface.co/docs/transformers/index) Transformers didasarkan TensorFlow pada API tf.Keras.Model.](https://www.tensorflow.org/api_docs/python/tf/keras/Model) Hugging Face Transformers juga menyediakan kelas model terlatih TensorFlow untuk membantu mengurangi upaya mengonfigurasi model pemrosesan bahasa alami (NLP). Setelah membuat skrip pelatihan Anda sendiri menggunakan perpustakaan Transformers, Anda dapat menjalankan skrip pelatihan menggunakan `HuggingFace` estimator SageMaker AI dengan kelas konfigurasi SageMaker Training Compiler seperti yang ditunjukkan pada topik sebelumnya di. [Jalankan Pekerjaan TensorFlow Pelatihan dengan Kompiler SageMaker Pelatihan](training-compiler-enable-tensorflow.md) SageMaker Training Compiler secara otomatis mengoptimalkan beban kerja pelatihan model yang dibangun di atas TensorFlow API asli atau API Keras tingkat tinggi, seperti model transformator. TensorFlow **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 memulai 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** + [Menggunakan Keras](#training-compiler-tensorflow-models-transformers-keras) + [Tanpa Keras](#training-compiler-tensorflow-models-transformers-no-keras) ### Menggunakan Keras Untuk akselerasi kompiler terbaik, sebaiknya gunakan model yang merupakan subclass dari TensorFlow Keras ([tf.Keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)). Seperti disebutkan di halaman [tur Cepat](https://huggingface.co/docs/transformers/quicktour) dalam dokumentasi *Hugging Face Transformers*, Anda dapat menggunakan model sebagai model Keras TensorFlow biasa. #### Untuk pelatihan GPU tunggal Tidak ada perubahan tambahan yang perlu Anda lakukan dalam skrip pelatihan. #### Untuk pelatihan terdistribusi SageMaker Akselerasi Training Compiler bekerja secara transparan untuk beban kerja multi-GPU saat model dibuat dan dilatih menggunakan Keras APIs dalam lingkup panggilan. [https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy](https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy) 1. Pilih strategi pelatihan terdistribusi yang tepat. 1. Untuk multi-GPU simpul tunggal, gunakan `tf.distribute.MirroredStrategy` untuk mengatur strategi. ``` strategy = tf.distribute.MirroredStrategy() ``` 1. Untuk multi-node multi-GPU, tambahkan kode berikut untuk mengatur konfigurasi pelatihan TensorFlow terdistribusi dengan benar sebelum membuat strategi. ``` def set_sm_dist_config(): DEFAULT_PORT = '8890' DEFAULT_CONFIG_FILE = '/opt/ml/input/config/resourceconfig.json' with open(DEFAULT_CONFIG_FILE) as f: config = json.loads(f.read()) current_host = config['current_host'] tf_config = { 'cluster': { 'worker': [] }, 'task': {'type': 'worker', 'index': -1} } for i, host in enumerate(config['hosts']): tf_config['cluster']['worker'].append("%s:%s" % (host, DEFAULT_PORT)) if current_host == host: tf_config['task']['index'] = i os.environ['TF_CONFIG'] = json.dumps(tf_config) set_sm_dist_config() ``` Gunakan `tf.distribute.MultiWorkerMirroredStrategy` untuk mengatur strategi. ``` strategy = tf.distribute.MultiWorkerMirroredStrategy() ``` 1. Dengan menggunakan strategi pilihan Anda, bungkus modelnya. ``` with strategy.scope(): # create a model and do fit ``` ### Tanpa Keras Jika Anda ingin membawa model kustom dengan loop pelatihan khusus menggunakan TensorFlow tanpa Keras, Anda harus membungkus model dan loop pelatihan dengan TensorFlow function decorator (`@tf.function`) untuk memanfaatkan akselerasi kompiler. SageMaker Training Compiler melakukan optimasi tingkat grafik, dan menggunakan dekorator untuk memastikan TensorFlow fungsi Anda diatur untuk berjalan dalam mode grafik. #### Untuk pelatihan GPU tunggal TensorFlow 2.0 atau yang lebih baru memiliki eksekusi bersemangat secara default, jadi Anda harus menambahkan `@tf.function` dekorator di depan setiap fungsi yang Anda gunakan untuk membangun model. TensorFlow #### Untuk pelatihan terdistribusi Selain perubahan yang diperlukan untuk [Menggunakan Keras untuk pelatihan terdistribusi](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-tensorflow-models.html#training-compiler-tensorflow-models-transformers-keras), Anda perlu memastikan bahwa fungsi yang akan dijalankan pada setiap GPU dianotasi`@tf.function`, sementara fungsi komunikasi lintas-GPU tidak dijelaskan. Contoh kode pelatihan akan terlihat seperti berikut: ``` @tf.function() def compiled_step(inputs, outputs): with tf.GradientTape() as tape: pred=model(inputs, training=True) total_loss=loss_object(outputs, pred)/args.batch_size gradients=tape.gradient(total_loss, model.trainable_variables) return total_loss, pred, gradients def train_step(inputs, outputs): total_loss, pred, gradients=compiled_step(inputs, outputs) if args.weight_decay > 0.: gradients=[g+v*args.weight_decay for g,v in zip(gradients, model.trainable_variables)] optimizer.apply_gradients(zip(gradients, model.trainable_variables)) train_loss.update_state(total_loss) train_accuracy.update_state(outputs, pred) @tf.function() def train_step_dist(inputs, outputs): strategy.run(train_step, args= (inputs, outputs)) ``` Perhatikan bahwa instruksi ini dapat digunakan untuk multi-GPU simpul tunggal dan multi-node multi-GPU.