Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# TensorFlow
<a name="training-compiler-tensorflow"></a>

Bawa TensorFlow model Anda sendiri ke SageMaker AI, dan jalankan pekerjaan pelatihan dengan Tra SageMaker ining Compiler.

## TensorFlow Model
<a name="training-compiler-tensorflow-models"></a>

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 mungkin meningkatkan total waktu pelatihan. 

### Menggunakan Keras (Direkomendasikan)
<a name="training-compiler-tensorflow-models-keras"></a>

Untuk akselerasi kompiler terbaik, kami sarankan menggunakan model yang merupakan subkelas dari TensorFlow Keras ([t ](https://www.tensorflow.org/api_docs/python/tf/keras/Model) f.keras.model).

#### Untuk pelatihan GPU tunggal
<a name="training-compiler-tensorflow-models-keras-single-gpu"></a>

Tidak ada perubahan tambahan yang perlu Anda buat dalam skrip pelatihan.

### Tanpa Keras
<a name="training-compiler-tensorflow-models-no-keras"></a>

SageMaker Training Compiler tidak mendukung eksekusi yang bersemangat di TensorFlow. Oleh karena itu, Anda harus membungkus model dan loop pelatihan Anda 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. [https://www.tensorflow.org/guide/intro_to_graphs](https://www.tensorflow.org/guide/intro_to_graphs)

#### Untuk pelatihan GPU tunggal
<a name="training-compiler-tensorflow-models-no-keras-single-gpu"></a>

TensorFlow 2.0 atau yang lebih baru memiliki eksekusi yang ingin aktif secara default, jadi Anda harus menambahkan `@tf.function` dekorator di depan setiap fungsi yang Anda gunakan untuk membangun TensorFlow model.

## TensorFlow Model dengan Transformer Wajah Pelukan
<a name="training-compiler-tensorflow-models-transformers"></a>

TensorFlow model dengan [ Hugging Face Transformers ](https://huggingface.co/docs/transformers/index) didasarkan pada API [ tf. ](https://www.tensorflow.org/api_docs/python/tf/keras/Model) Ker TensorFlow as.Model. Hugging Face Transformers juga menyediakan kelas model yang telah dilatih sebelumnya TensorFlow untuk membantu mengurangi upaya mengonfigurasi model pemrosesan bahasa alami (NLP). Setelah membuat skrip pelatihan Anda sendiri menggunakan pustaka Transformers, Anda dapat menjalankan skrip pelatihan menggunakan SageMaker AI `HuggingFace` ModelTrainer dengan kelas konfigurasi SageMaker Training Compiler seperti yang ditunjukkan pada topik sebelumnya di[Jalan TensorFlow kan Pekerjaan Pelatihan dengan Tra SageMaker ining Compiler](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 bantalan ke urutan terpanjang dalam batch dapat mengubah bentuk tensor untuk setiap batch pelatihan. Bentuk input dinamis dapat memulai 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**
+ [Menggunakan Keras](#training-compiler-tensorflow-models-transformers-keras)
+ [Tanpa Keras](#training-compiler-tensorflow-models-transformers-no-keras)

### Menggunakan Keras
<a name="training-compiler-tensorflow-models-transformers-keras"></a>

Untuk akselerasi kompiler terbaik, kami sarankan menggunakan model yang merupakan subkelas dari TensorFlow Keras ([t ](https://www.tensorflow.org/api_docs/python/tf/keras/Model) f.keras.model). Seperti disebutkan di [ halaman tur C ](https://huggingface.co/docs/transformers/quicktour) epat dalam dokumentasi * Hugging Face Transformers*, Anda dapat menggunakan model sebagai model TensorFlow Keras biasa.

#### Untuk pelatihan GPU tunggal
<a name="training-compiler-tensorflow-models-transformers-keras-single-gpu"></a>

Tidak ada perubahan tambahan yang perlu Anda buat dalam skrip pelatihan.

#### Untuk pelatihan terdistribusi
<a name="training-compiler-tensorflow-models-transformers-keras-distributed"></a>

SageMaker Akselerasi Kompiler Pelatihan bekerja secara transparan untuk beban kerja multi-GPU ketika model dibangun dan dilatih menggunakan API Keras dalam lingkup panggilan. [`tf.distribute.Strategy.scope()`](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 terdistribusi TensorFlow 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 menetapkan strategi.

      ```
      strategy = tf.distribute.MultiWorkerMirroredStrategy()
      ```

1. Menggunakan strategi pilihan Anda, bungkus model.

   ```
   with strategy.scope():
       # create a model and do fit
   ```

### Tanpa Keras
<a name="training-compiler-tensorflow-models-transformers-no-keras"></a>

Jika Anda ingin membawa model khusus 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
<a name="training-compiler-tensorflow-models-transformers-no-keras-single-gpu"></a>

TensorFlow 2.0 atau yang lebih baru memiliki eksekusi yang ingin aktif secara default, jadi Anda harus menambahkan `@tf.function` dekorator di depan setiap fungsi yang Anda gunakan untuk membangun TensorFlow model.

#### Untuk pelatihan terdistribusi
<a name="training-compiler-tensorflow-models-transformers-no-keras-distributed"></a>

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 dianotasi. 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 single-node dan multi-node multi-GPU.