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

# Gunakan Debugger dengan wadah pelatihan khusus
<a name="debugger-bring-your-own-container"></a>

Amazon SageMaker Debugger tersedia untuk semua model pembelajaran mendalam yang Anda bawa ke Amazon SageMaker AI. SageMaker AI `Estimator` API AWS CLI, dan Debugger APIs memungkinkan Anda menggunakan gambar dasar Docker apa pun untuk membangun dan menyesuaikan wadah untuk melatih model Anda. Untuk menggunakan Debugger dengan kontainer yang disesuaikan, Anda perlu membuat perubahan minimal pada skrip pelatihan Anda untuk mengimplementasikan callback hook Debugger dan mengambil tensor dari pekerjaan pelatihan. Bagian berikut akan memandu Anda melalui cara menggunakan Debugger dengan Custom Training Containers.

Anda memerlukan sumber daya berikut untuk membangun wadah yang disesuaikan dengan Debugger.
+ [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable)
+ [Pustaka klien SMDebug open source](https://github.com/awslabs/sagemaker-debugger)
+ Gambar dasar Docker pilihan Anda
+ Skrip pelatihan Anda dengan hook Debugger terdaftar — Untuk informasi lebih lanjut tentang mendaftarkan hook Debugger ke skrip pelatihan Anda, lihat. [Daftarkan kait Debugger ke skrip pelatihan Anda](#debugger-script-mode)

Untuk end-to-end contoh menggunakan Debugger dengan wadah pelatihan khusus, lihat contoh buku catatan berikut.
+ [Bangun Container Pelatihan Kustom dan Pekerjaan Pelatihan Debug dengan Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/build_your_own_container_with_debugger/debugger_byoc.html)

**Tip**  
Wadah khusus dengan panduan Debugger ini adalah perpanjangan dari [Mengadaptasi wadah pelatihan Anda sendiri](adapt-training-container.md) panduan yang memandu Anda secara menyeluruh cara membangun dan mendorong wadah pelatihan khusus Anda ke Amazon ECR.

## Bersiaplah untuk membangun wadah pelatihan khusus
<a name="debugger-bring-your-own-container-1"></a>

Untuk membangun wadah docker, struktur dasar file akan terlihat seperti berikut:

```
├── debugger_custom_container_test_notebook.ipynb      # a notebook to run python snippet codes
└── debugger_custom_container_test_folder              # this is a docker folder
    ├──  your-training-script.py                       # your training script with Debugger hook
    └──  Dockerfile                                    # a Dockerfile to build your own container
```

## Daftarkan kait Debugger ke skrip pelatihan Anda
<a name="debugger-script-mode"></a>

Untuk men-debug pelatihan model Anda, Anda perlu menambahkan hook Debugger ke skrip pelatihan Anda.

**catatan**  
Langkah ini diperlukan untuk mengumpulkan parameter model (tensor keluaran) untuk men-debug pelatihan model Anda. Jika Anda hanya ingin memantau dan membuat profil, Anda dapat melewati langkah pendaftaran hook ini dan mengecualikan `debugger_hook_config` parameter saat membuat estimater.

Contoh kode berikut menunjukkan struktur skrip pelatihan menggunakan model Keras ResNet 50 dan cara meneruskan hook Debugger sebagai callback Keras untuk debugging. Untuk menemukan skrip pelatihan lengkap, lihat [skrip TensorFlow pelatihan dengan kait SageMaker Debugger](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-debugger/build_your_own_container_with_debugger/docker/tf_keras_resnet_byoc.py).

```
# An example of training script (your-training-script.py)
import tensorflow.compat.v2 as tf
from tensorflow.keras.applications.resnet50 import ResNet50
import smdebug.tensorflow as smd

def train(batch_size, epoch, model, hook):

    ...
    model.fit(X_train, Y_train,
              batch_size=batch_size,
              epochs=epoch,
              validation_data=(X_valid, Y_valid),
              shuffle=True,

              # smdebug modification: Pass the Debugger hook in the main() as a Keras callback
              callbacks=[hook])

def main():
    parser=argparse.ArgumentParser(description="Train resnet50 cifar10")

    # hyperparameter settings
    parser.add_argument(...)
    
    args = parser.parse_args()

    model=ResNet50(weights=None, input_shape=(32,32,3), classes=10)

    # Add the following line to register the Debugger hook for Keras.
    hook=smd.KerasHook.create_from_json_file()

    # Start the training.
    train(args.batch_size, args.epoch, model, hook)

if __name__ == "__main__":
    main()
```

Untuk informasi selengkapnya tentang mendaftarkan hook Debugger untuk kerangka kerja dan algoritme yang didukung, lihat tautan berikut di pustaka klien: SMDebug 
+ [SMDebug TensorFlow kait](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/tensorflow.md)
+ [SMDebug PyTorch kait](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/pytorch.md)
+ [SMDebug MXNet kait](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/mxnet.md)
+ [SMDebug XGBoost kait](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/xgboost.md)

Dalam contoh skrip pelatihan notebook berikut, Anda dapat menemukan lebih banyak contoh tentang cara menambahkan kait Debugger ke skrip pelatihan dan mengumpulkan tensor keluaran secara detail:
+ [Debugger dalam mode skrip dengan kerangka 2.1 TensorFlow ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/tf2-keras-custom-container.html)

  Untuk melihat perbedaan antara menggunakan Debugger dalam Deep Learning Container dan dalam mode skrip, buka notebook ini dan letakkan dan [Debugger sebelumnya dalam contoh notebook Deep Learning Container TensorFlow v2.1](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_zero_code_change/tf2-keras-default-container.html) berdampingan. 

   Dalam mode skrip, bagian konfigurasi kait dihapus dari skrip tempat Anda mengatur estimator. Sebagai gantinya, fitur kait Debugger digabungkan ke dalam skrip pelatihan, skrip [ ResNet pelatihan TensorFlow Keras dalam mode skrip](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/src/tf_keras_resnet_byoc.py). Skrip pelatihan mengimpor `smdebug` perpustakaan di lingkungan TensorFlow Keras yang diperlukan untuk berkomunikasi dengan algoritma TensorFlow ResNet 50. Ini juga secara manual mengimplementasikan fungsionalitas `smdebug` hook dengan menambahkan `callbacks=[hook]` argumen di dalam `train` fungsi (di baris 49), dan dengan menambahkan konfigurasi hook manual (pada baris 89) yang disediakan melalui SageMaker Python SDK.

  Contoh mode skrip ini menjalankan pekerjaan pelatihan dalam kerangka TF 2.1 untuk perbandingan langsung dengan perubahan skrip nol dalam contoh TF 2.1. Manfaat menyiapkan Debugger dalam mode skrip adalah fleksibilitas untuk memilih versi kerangka kerja yang tidak tercakup oleh AWS Deep Learning Containers. 
+ [Menggunakan Amazon SageMaker Debugger dalam PyTorch Container dalam Mode Script](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_custom_container)

  Notebook ini memungkinkan Debugger dalam mode skrip dalam kerangka PyTorch v1.3.1. PyTorchv1.3.1 didukung oleh kontainer SageMaker AI, dan contoh ini menunjukkan detail tentang cara memodifikasi skrip pelatihan. 

   PyTorch Estimator SageMaker AI sudah dalam mode skrip secara default. Di notebook, baris untuk mengaktifkan `script_mode` tidak termasuk dalam konfigurasi estimator.

  Notebook ini menunjukkan langkah-langkah rinci untuk mengubah [skrip PyTorch pelatihan asli](https://github.com/pytorch/examples/blob/master/mnist/main.py) ke versi yang dimodifikasi untuk mengaktifkan Debugger. Selain itu, contoh ini menunjukkan bagaimana Anda dapat menggunakan aturan bawaan Debugger untuk mendeteksi masalah pelatihan seperti masalah gradien yang hilang, dan fitur uji coba Debugger untuk memanggil dan menganalisis tensor yang disimpan. 

## Buat dan konfigurasikan Dockerfile
<a name="debugger-bring-your-own-container-2"></a>

Buka SageMaker AI Anda JupyterLab dan buat folder baru, `debugger_custom_container_test_folder` dalam contoh ini, untuk menyimpan skrip pelatihan Anda dan`Dockerfile`. Contoh kode berikut adalah `Dockerfile` yang menyertakan pujian docker build penting. Tempel kode berikut ke dalam file `Dockerfile` teks dan simpan. Unggah skrip latihan Anda ke folder yang sama.

```
# Specify a docker base image
FROM tensorflow/tensorflow:2.2.0rc2-gpu-py3
RUN /usr/bin/python3 -m pip install --upgrade pip
RUN pip install --upgrade protobuf

# Install required packages to enable the SageMaker Python SDK and the smdebug library
RUN pip install sagemaker-training
RUN pip install smdebug
CMD ["bin/bash"]
```

Jika Anda ingin menggunakan gambar AWS Deep Learning Container yang sudah dibuat sebelumnya, lihat Gambar [AWS Deep Learning Containers yang Tersedia](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/).

## Bangun dan dorong gambar pelatihan khusus ke Amazon ECR
<a name="debugger-bring-your-own-container-3"></a>

Buat buku catatan pengujian`debugger_custom_container_test_notebook.ipynb`,, dan jalankan kode berikut di sel notebook. Ini akan mengakses `debugger_byoc_test_docker` direktori, membangun docker dengan yang ditentukan`algorithm_name`, dan mendorong docker container ke Amazon ECR Anda.

```
import boto3

account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'sagemaker-debugger-mnist-byoc-tf2'
tag = ':latest'

region = boto3.session.Session().region_name

uri_suffix = 'amazonaws.com'
if region in ['cn-north-1', 'cn-northwest-1']:
    uri_suffix = 'amazonaws.com.cn'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)

!docker build -t $ecr_repository docker
!$(aws ecr get-login --region $region --registry-ids $account_id --no-include-email)
!aws ecr create-repository --repository-name $ecr_repository
!docker tag {ecr_repository + tag} $byoc_image_uri
!docker push $byoc_image_uri
```

**Tip**  
Jika Anda menggunakan salah satu gambar dasar AWS Deep Learning Container, jalankan kode berikut untuk masuk ke Amazon ECR dan akses ke repositori gambar Deep Learning Container.  

```
! aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com
```

## Jalankan dan debug pekerjaan pelatihan menggunakan wadah pelatihan khusus
<a name="debugger-bring-your-own-container-4"></a>

Setelah Anda membangun dan mendorong docker container Anda ke Amazon ECR, konfigurasikan estimator SageMaker AI dengan skrip pelatihan dan parameter khusus Debugger. Setelah Anda menjalankan`estimator.fit()`, Debugger akan mengumpulkan tensor keluaran, memantaunya, dan mendeteksi masalah pelatihan. Dengan menggunakan tensor yang disimpan, Anda dapat menganalisis lebih lanjut pekerjaan pelatihan dengan menggunakan fitur dan alat `smdebug` inti. Mengonfigurasi alur kerja proses pemantauan aturan Debugger dengan Amazon CloudWatch Events dan AWS Lambda, Anda dapat mengotomatiskan proses tugas pelatihan yang berhenti setiap kali aturan Debugger menemukan masalah pelatihan.

```
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker.debugger import Rule, DebuggerHookConfig, CollectionConfig, rule_configs

profiler_config=ProfilerConfig(...)
debugger_hook_config=DebuggerHookConfig(...)
rules=[
    Rule.sagemaker(rule_configs.built_in_rule()),
    ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]

estimator=Estimator(
    image_uri=byoc_image_uri,
    entry_point="./debugger_custom_container_test_folder/your-training-script.py"
    role=sagemaker.get_execution_role(),
    base_job_name='debugger-custom-container-test',
    instance_count=1,
    instance_type='ml.p3.2xlarge',
    
    # Debugger-specific parameters
    profiler_config=profiler_config,
    debugger_hook_config=debugger_hook_config,
    rules=rules
)

# start training
estimator.fit()
```