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>

**catatan**  
Amazon SageMaker Debugger tidak lagi terbuka untuk pelanggan baru. Pelanggan yang sudah ada dapat terus menggunakan layanan seperti biasa. AWS terus berinvestasi dalam peningkatan keamanan dan ketersediaan untuk Debugger, tetapi kami tidak berencana untuk memperkenalkan fitur baru. Untuk informasi selengkapnya, lihat [Perubahan ketersediaan debugger](debugger-availability-change.md). 

Amazon SageMaker Debugger tersedia untuk semua model pembelajaran mendalam yang Anda bawa ke Amazon SageMaker AI. `ModelTrainer`API SageMaker AI AWS CLI, dan API Debugger memungkinkan Anda menggunakan image dasar Docker apa pun untuk membangun dan menyesuaikan wadah untuk melatih model Anda. Untuk menggunakan Debugger dengan wadah khusus, 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 Kontainer Pelatihan Kustom.

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

Untuk contoh end-to-end menggunakan Debugger dengan wadah pelatihan khusus, lihat contoh buku catatan berikut.
+ [Bangun Kontainer 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 harus 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 Debugger hook 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 kait ini dan mengecualikan `debugger_hook_config` parameter saat membuat estimater.

Kode contoh 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 SageMaker Debugger hook](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 algoritma yang didukung, lihat tautan berikut di pustaka klien SMDebug:
+ [Pengait SMDebug TensorFlow ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/tensorflow.md)
+ [Pengait SMDebug PyTorch ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/pytorch.md)
+ [Pengait SMDebug MXnet ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/mxnet.md)
+ [Pengait SMDebug XGBoost ](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 rinci:
+ [Debugger dalam mode skrip dengan kerangka kerja TensorFlow 2.1 ](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 serta Debugger sebelumnya dalam contoh notebook Deep Learning Container TensorFlow v2.1 ber ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_zero_code_change/tf2-keras-default-container.html) dampingan. 

   Dalam mode skrip, bagian konfigurasi kait dihapus dari skrip tempat Anda mengatur ModelTrainer. Sebagai gantinya, fitur pengait Debugger digabungkan ke dalam skrip pelatihan, skrip [ TensorFlow ResNet pelatihan Keras dalam mode ](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/src/tf_keras_resnet_byoc.py) skrip. Skrip pelatihan mengimpor pust `smdebug` aka 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 kait manual (di baris 89) yang disediakan melalui SageMaker Python SDK.

  Contoh mode skrip ini menjalankan pekerjaan pelatihan dalam kerangka kerja 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 Con PyTorch tainer dalam Mode Skrip ](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. 

   SageMaker AI PyTorch ModelTrainer sudah dalam mode skrip secara default. Di notebook, baris yang akan di `script_mode` aktifkan tidak termasuk dalam ModelTrainer konfigurasi.

  Buku catatan ini menunjukkan langkah-langkah terperinci 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 build docker penting. Tempelkan kode berikut ke dalam file `Dockerfile` teks dan simpan. Unggah skrip pelatihan 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 Kontainer Pembelajaran Mendalam yang AWS sudah dibuat sebelumnya, lihat Gambar Wadah Pem [ belajaran AWS Mendalam 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 uji`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 wadah docker 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 mengakses 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 wadah docker Anda ke Amazon ECR, konfigurasikan SageMaker AI ModelTrainer dengan skrip pelatihan Anda dan Debugger-specific parameternya. Setelah Anda menjalankan`model_trainer.train()`, 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. Mengkonfigurasi alur kerja proses pemantauan aturan Debugger dengan Amazon Ev CloudWatch ents dan AWS Lambda, Anda dapat mengotomatiskan proses pekerjaan pelatihan yang berhenti setiap kali aturan Debugger menemukan masalah pelatihan.

```
import sagemaker
from sagemaker.train import ModelTrainer
from sagemaker.core.debugger import Rule, DebuggerHookConfig, CollectionConfig, rule_configs
from sagemaker.core.helper.session_helper import get_execution_role

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

from sagemaker.train.configs import SourceCode, Compute

model_trainer=ModelTrainer(
    training_image=byoc_image_uri,
    source_code=SourceCode(entry_script="./debugger_custom_container_test_folder/your-training-script.py"),
    role=get_execution_role(),
    base_job_name='debugger-custom-container-test',
    compute=Compute(instance_type='ml.p3.2xlarge', instance_count=1),
    
    # Debugger-specific parameters
    profiler_config=profiler_config,
    debugger_hook_config=debugger_hook_config,
    rules=rules
)

# start training
model_trainer.train()
```