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 SageMaker Training 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 dapat meningkatkan total waktu pelatihan. 

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

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
<a name="training-compiler-tensorflow-models-keras-single-gpu"></a>

Tidak ada perubahan tambahan yang perlu Anda lakukan 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 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
<a name="training-compiler-tensorflow-models-no-keras-single-gpu"></a>

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
<a name="training-compiler-tensorflow-models-transformers"></a>

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
<a name="training-compiler-tensorflow-models-transformers-keras"></a>

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
<a name="training-compiler-tensorflow-models-transformers-keras-single-gpu"></a>

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

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

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
<a name="training-compiler-tensorflow-models-transformers-no-keras"></a>

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
<a name="training-compiler-tensorflow-models-transformers-no-keras-single-gpu"></a>

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