

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

# Wadah dengan algoritma pelatihan khusus
<a name="your-algorithms-training-algo"></a>

Bagian ini menjelaskan bagaimana Amazon SageMaker AI berinteraksi dengan wadah Docker yang menjalankan algoritme pelatihan khusus Anda. Gunakan informasi ini untuk menulis kode pelatihan dan membuat gambar Docker untuk algoritme pelatihan Anda. 

**Topics**
+ [

# Bagaimana Amazon SageMaker AI Menjalankan Gambar Pelatihan Anda
](your-algorithms-training-algo-dockerfile.md)
+ [

# Bagaimana Amazon SageMaker AI Memberikan Informasi Pelatihan
](your-algorithms-training-algo-running-container.md)
+ [

# Jalankan Pelatihan dengan EFA
](your-algorithms-training-efa.md)
+ [

# Bagaimana Amazon SageMaker AI Sinyal Algoritma Sukses dan Kegagalan
](your-algorithms-training-signal-success-failure.md)
+ [

# Bagaimana Amazon SageMaker AI Memproses Output Pelatihan
](your-algorithms-training-algo-output.md)

# Bagaimana Amazon SageMaker AI Menjalankan Gambar Pelatihan Anda
<a name="your-algorithms-training-algo-dockerfile"></a>

Anda dapat menggunakan skrip entrypoint khusus untuk mengotomatiskan infrastruktur untuk melatih di lingkungan produksi. Jika Anda meneruskan skrip entrypoint Anda ke wadah Docker Anda, Anda juga dapat menjalankannya sebagai skrip mandiri tanpa membangun kembali gambar Anda. SageMaker AI memproses gambar pelatihan Anda menggunakan skrip entrypoint kontainer Docker. 

Bagian ini menunjukkan cara menggunakan entrypoint khusus tanpa menggunakan toolkit pelatihan. Jika Anda ingin menggunakan entrypoint khusus tetapi tidak terbiasa dengan cara mengonfigurasi wadah Docker secara manual, kami sarankan Anda menggunakan perpustakaan toolkit [SageMaker pelatihan](https://github.com/aws/sagemaker-training-toolkit) sebagai gantinya. Untuk informasi selengkapnya tentang cara menggunakan toolkit pelatihan, lihat[Mengadaptasi wadah pelatihan Anda sendiri](adapt-training-container.md). 

Secara default, SageMaker AI mencari skrip yang disebut `train` di dalam wadah Anda. Anda juga dapat secara manual memberikan entrypoint kustom Anda sendiri dengan menggunakan `ContainerArguments` dan `ContainerEntrypoint` parameter API. [AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html) 

Anda memiliki dua opsi berikut untuk mengonfigurasi wadah Docker Anda secara manual untuk menjalankan gambar Anda.
+ Gunakan [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API dan wadah Docker dengan instruksi entrypoint yang terdapat di dalamnya.
+ Gunakan `CreateTrainingJob` API, dan teruskan skrip pelatihan Anda dari luar wadah Docker Anda.

Jika Anda meneruskan skrip pelatihan Anda dari luar wadah Docker Anda, Anda tidak perlu membangun kembali wadah Docker saat Anda memperbarui skrip Anda. Anda juga dapat menggunakan beberapa skrip berbeda untuk dijalankan di wadah yang sama.

Skrip entrypoint Anda harus berisi kode pelatihan untuk gambar Anda. Jika Anda menggunakan `source_dir` parameter opsional di dalam [estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html), parameter tersebut harus mereferensikan jalur Amazon S3 relatif ke folder yang berisi skrip titik masuk Anda. Anda dapat mereferensikan beberapa file menggunakan `source_dir` parameter. Jika Anda tidak menggunakan`source_dir`, Anda dapat menentukan titik masuk menggunakan parameter. `entry_point` Untuk contoh skrip entrypoint khusus yang berisi estimator, lihat [Membawa Model Anda Sendiri dengan Mode Skrip SageMaker AI](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-script-mode/sagemaker-script-mode.html).

SageMaker Pelatihan model AI mendukung bucket direktori S3 Express One Zone berkinerja tinggi sebagai lokasi input data untuk mode file, mode file cepat, dan mode pipa. Anda juga dapat menggunakan bucket direktori S3 Express One Zone untuk menyimpan output pelatihan Anda. Untuk menggunakan S3 Express One Zone, berikan URI bucket direktori S3 Express One Zone, bukan bucket tujuan umum Amazon S3. Anda hanya dapat mengenkripsi data keluaran SageMaker AI di bucket direktori dengan enkripsi sisi server dengan kunci terkelola Amazon S3 (SSE-S3). Enkripsi sisi server dengan AWS KMS kunci (SSE-KMS) saat ini tidak didukung untuk menyimpan data keluaran SageMaker AI dalam bucket direktori. Untuk informasi selengkapnya, lihat [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html).

## Jalankan pekerjaan pelatihan dengan skrip entrypoint yang dibundel di dalam wadah Docker
<a name="your-algorithms-training-algo-dockerfile-api-ep-in"></a>

SageMaker AI dapat menjalankan skrip entrypoint yang dibundel di dalam wadah Docker Anda. 
+ Secara default, Amazon SageMaker AI menjalankan wadah berikut.

  ```
  docker run image train
  ```
+ SageMaker AI mengganti pernyataan [CMD](https://docs.docker.com/engine/reference/builder/#cmd) default apa pun dalam wadah dengan menentukan `train` argumen setelah nama gambar. Dalam wadah Docker Anda, gunakan `exec` bentuk `ENTRYPOINT` instruksi berikut.

  ```
  ENTRYPOINT ["executable", "param1", "param2", ...]
  ```

  Contoh berikut menunjukkan bagaimana menentukan instruksi entrypoint python yang disebut. `k-means-algorithm.py`

  ```
  ENTRYPOINT ["python", "k-means-algorithm.py"]
  ```

  `exec`Bentuk `ENTRYPOINT` instruksi memulai eksekusi secara langsung, bukan sebagai anak dari. `/bin/sh` Ini memungkinkannya untuk menerima sinyal seperti `SIGTERM` dan `SIGKILL` dari SageMaker APIs. Ketentuan berikut berlaku saat menggunakan SageMaker APIs. 
  + [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API memiliki kondisi penghentian yang mengarahkan SageMaker AI untuk menghentikan pelatihan model setelah waktu tertentu. 
  + Berikut ini menunjukkan [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html)API. API ini mengeluarkan yang setara dengan perintah batas waktu 2 menit untuk menghentikan penampung yang ditentukan dengan anggun. `docker stop`

    ```
    docker stop -t 120
    ```

    Perintah mencoba menghentikan wadah yang sedang berjalan dengan mengirimkan `SIGTERM` sinyal. Setelah batas waktu 2 menit, API mengirim `SIGKILL` dan menghentikan kontainer secara paksa. Jika wadah menangani `SIGTERM` dengan anggun dan keluar dalam waktu 120 detik sejak menerimanya, tidak ada `SIGKILL` yang dikirim. 

  Jika Anda ingin akses ke artefak model perantara setelah SageMaker AI menghentikan pelatihan, tambahkan kode untuk menangani penyimpanan artefak di handler Anda`SIGTERM`.
+ Jika Anda berencana menggunakan perangkat GPU untuk pelatihan model, pastikan kontainer Anda `nvidia-docker` kompatibel. Sertakan hanya toolkit CUDA pada wadah; jangan bundel driver NVIDIA dengan gambar. Untuk informasi selengkapnya`nvidia-docker`, lihat [NVIDIA/NVIDIA-Docker](https://github.com/NVIDIA/nvidia-docker).
+ Anda tidak dapat menggunakan `tini` penginisialisasi sebagai skrip titik masuk Anda dalam wadah SageMaker AI karena bingung dengan argumen dan. `train` `serve`
+ `/opt/ml`dan semua subdirektori dicadangkan oleh SageMaker pelatihan. Saat membuat image Docker algoritme Anda, pastikan Anda tidak menempatkan data apa pun yang diperlukan oleh algoritme Anda di direktori ini. Karena jika Anda melakukannya, data mungkin tidak lagi terlihat selama pelatihan.

Untuk menggabungkan skrip shell atau Python Anda di dalam image Docker Anda, atau untuk menyediakan skrip dalam bucket Amazon S3 atau dengan menggunakan ( AWS Command Line Interface CLI), lanjutkan ke bagian berikut.

### Bundel skrip shell Anda dalam wadah Docker
<a name="your-algorithms-training-algo-dockerfile-script-sh"></a>

 Jika Anda ingin menggabungkan skrip shell khusus di dalam gambar Docker Anda, gunakan langkah-langkah berikut. 

1. Salin skrip shell Anda dari direktori kerja Anda ke dalam wadah Docker Anda. Cuplikan kode berikut menyalin skrip entrypoint kustom `custom_entrypoint.sh` dari direktori kerja saat ini ke wadah Docker yang terletak di. `mydir` Contoh berikut mengasumsikan bahwa image Docker dasar telah diinstal Python.

   ```
   FROM <base-docker-image>:<tag>
   
   # Copy custom entrypoint from current dir to /mydir on container
   COPY ./custom_entrypoint.sh /mydir/
   ```

1. Buat dan dorong wadah Docker ke Amazon Elastic Container Registry ([Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) dengan mengikuti petunjuk di [Mendorong gambar Docker di Panduan](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) Pengguna *Amazon ECR*.

1. Luncurkan pekerjaan pelatihan dengan menjalankan AWS CLI perintah berikut.

   ```
   aws --region <your-region> sagemaker create-training-job \
   --training-job-name <your-training-job-name> \
   --role-arn <your-execution-role-arn> \
   --algorithm-specification '{ \ 
       "TrainingInputMode": "File", \
       "TrainingImage": "<your-ecr-image>", \
       "ContainerEntrypoint": ["/bin/sh"], \
       "ContainerArguments": ["/mydir/custom_entrypoint.sh"]}' \
   --output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \
   --resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \
   --stopping-condition '{"MaxRuntimeInSeconds": 180}'
   ```

### Bundel skrip Python Anda dalam wadah Docker
<a name="your-algorithms-training-algo-dockerfile-script-py"></a>

Untuk menggabungkan skrip Python kustom di dalam gambar Docker Anda, gunakan langkah-langkah berikut. 

1. Salin skrip Python Anda dari direktori kerja Anda ke dalam wadah Docker Anda. Cuplikan kode berikut menyalin skrip entrypoint kustom `custom_entrypoint.py` dari direktori kerja saat ini ke wadah Docker yang terletak di. `mydir`

   ```
   FROM <base-docker-image>:<tag>
   # Copy custom entrypoint from current dir to /mydir on container
   COPY ./custom_entrypoint.py /mydir/
   ```

1. Luncurkan pekerjaan pelatihan dengan menjalankan AWS CLI perintah berikut.

   ```
   --algorithm-specification '{ \ 
       "TrainingInputMode": "File", \
       "TrainingImage": "<your-ecr-image>", \
       "ContainerEntrypoint": ["python"], \
       "ContainerArguments": ["/mydir/custom_entrypoint.py"]}' \
   ```

## Jalankan pekerjaan pelatihan dengan skrip titik masuk di luar wadah Docker
<a name="your-algorithms-training-algo-dockerfile-api-pass-ep"></a>

Anda dapat menggunakan wadah Docker Anda sendiri untuk pelatihan dan meneruskan skrip titik masuk dari luar wadah Docker. Ada beberapa manfaat untuk menyusun skrip entrypoint Anda di luar wadah. Jika Anda memperbarui skrip entrypoint Anda, Anda tidak perlu membangun kembali wadah Docker. Anda juga dapat menggunakan beberapa skrip berbeda untuk dijalankan di wadah yang sama. 

Tentukan lokasi skrip pelatihan Anda menggunakan `ContainerEntrypoint` dan `ContainerArguments` parameter [AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API. Titik masuk dan argumen ini berperilaku dengan cara yang sama seperti titik masuk dan argumen Docker. Nilai dalam parameter ini mengesampingkan yang sesuai `ENTRYPOINT` atau `CMD` disediakan sebagai bagian dari wadah Docker. 

Saat Anda meneruskan skrip entrypoint kustom Anda ke wadah pelatihan Docker Anda, input yang Anda berikan menentukan perilaku penampung.
+ Misalnya, jika Anda hanya menyediakan`ContainerEntrypoint`, sintaks permintaan menggunakan CreateTrainingJob API adalah sebagai berikut.

  ```
  {
      "AlgorithmSpecification": {
          "ContainerEntrypoint": ["string"],   
          ...     
          }       
  }
  ```

  Kemudian, backend SageMaker pelatihan menjalankan entrypoint khusus Anda sebagai berikut.

  ```
  docker run --entrypoint <ContainerEntrypoint> image
  ```
**catatan**  
Jika `ContainerEntrypoint` disediakan, backend SageMaker pelatihan menjalankan gambar dengan titik masuk yang diberikan dan mengganti default pada gambar. `ENTRYPOINT`
+ Jika Anda hanya menyediakan`ContainerArguments`, SageMaker AI mengasumsikan bahwa wadah Docker berisi skrip titik masuk. Sintaks permintaan menggunakan `CreateTrainingJob` API adalah sebagai berikut.

  ```
  {
      "AlgorithmSpecification": {
          "ContainerArguments": ["arg1", "arg2"],
          ...
      }
  }
  ```

  Backend SageMaker pelatihan menjalankan entrypoint kustom Anda sebagai berikut.

  ```
  docker run image <ContainerArguments>
  ```
+ Jika Anda memberikan keduanya `ContainerEntrypoint` dan`ContainerArguments`, maka sintaks permintaan menggunakan `CreateTrainingJob` API adalah sebagai berikut.

  ```
  {
      "AlgorithmSpecification": {
          "ContainerEntrypoint": ["string"],
          "ContainerArguments": ["arg1", "arg2"],
          ...
      }
  }
  ```

   Backend SageMaker pelatihan menjalankan entrypoint kustom Anda sebagai berikut.

  ```
  docker run --entrypoint <ContainerEntrypoint> image <ContainerArguments>
  ```

Anda dapat menggunakan `InputDataConfig` sumber apa pun yang didukung di `CreateTrainingJob` API untuk menyediakan skrip titik masuk untuk menjalankan image pelatihan Anda. 

### Berikan skrip entrypoint Anda di bucket Amazon S3
<a name="your-algorithms-training-algo-dockerfile-script-s3"></a>

 Untuk menyediakan skrip entrypoint khusus menggunakan bucket S3, gunakan `S3DataSource` parameter [DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)API untuk menentukan lokasi skrip. Jika Anda menggunakan `S3DataSource` parameter, berikut ini diperlukan.
+ [InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)Harus dari tipe`File`.
+ [S3 DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource) harus. `FullyReplicated`

Contoh berikut memiliki skrip bernama custom\$1entrypoint.sh ditempatkan di jalur ke bucket `s3://<bucket-name>/<bucket prefix>/custom_entrypoint.sh` S3.

```
#!/bin/bash
echo "Running custom_entrypoint.sh"
echo "Hello you have provided the following arguments: " "$@"
```

Selanjutnya, Anda harus mengatur konfigurasi saluran data input untuk menjalankan pekerjaan pelatihan. Lakukan ini baik dengan menggunakan secara AWS CLI langsung atau dengan file JSON.

#### Konfigurasikan saluran data input menggunakan AWS CLI dengan file JSON
<a name="your-algorithms-training-algo-dockerfile-script-s3-json"></a>

Untuk mengkonfigurasi saluran data input Anda dengan file JSON, gunakan AWS CLI seperti yang ditunjukkan dalam struktur kode berikut. Pastikan bahwa semua bidang berikut menggunakan sintaks permintaan yang ditentukan dalam [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)API.

```
// run-my-training-job.json
{
 "[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-AlgorithmSpecification)": { 
        "ContainerEntrypoint": ["/bin/sh"],
        "ContainerArguments": ["/opt/ml/input/data/<your_channel_name>/custom_entrypoint.sh"],
         ...
   },
  "[InputDataConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-InputDataConfig)": [ 
    { 
        "[ChannelName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-ChannelName)": "<your_channel_name>",
        "[DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-DataSource)": { 
            "[S3DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)": { 
                "[S3DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataDistributionType)": "FullyReplicated",
                "[S3DataType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataType)": "S3Prefix",
                "[S3Uri](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3Uri)": "s3://<bucket-name>/<bucket_prefix>"
            }
        },
        "[InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)": "File",
    },
    ...]
}
```

Selanjutnya, jalankan AWS CLI perintah untuk meluncurkan pekerjaan pelatihan dari file JSON sebagai berikut.

```
aws sagemaker create-training-job --cli-input-json file://run-my-training-job.json
```

#### Konfigurasikan saluran data input menggunakan AWS CLI langsung
<a name="your-algorithms-training-algo-dockerfile-script-s3-directly"></a>

Untuk mengkonfigurasi saluran data input Anda tanpa file JSON, gunakan struktur AWS CLI kode berikut.

```
aws --region <your-region> sagemaker create-training-job \
--training-job-name <your-training-job-name> \
--role-arn <your-execution-role-arn> \
--algorithm-specification '{ \
    "TrainingInputMode": "File", \
    "TrainingImage": "<your-ecr-image>", \
    "ContainerEntrypoint": ["/bin/sh"], \
    "ContainerArguments": ["/opt/ml/input/data/<your_channel_name>/custom_entrypoint.sh"]}' \
--input-data-config '[{ \
    "ChannelName":"<your_channel_name>", \
    "DataSource":{ \
        "S3DataSource":{ \
            "S3DataType":"S3Prefix", \
            "S3Uri":"s3://<bucket-name>/<bucket_prefix>", \
            "S3DataDistributionType":"FullyReplicated"}}}]' \
--output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \
--resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \
--stopping-condition '{"MaxRuntimeInSeconds": 180}'
```

# Bagaimana Amazon SageMaker AI Memberikan Informasi Pelatihan
<a name="your-algorithms-training-algo-running-container"></a>

Bagian ini menjelaskan bagaimana SageMaker AI membuat informasi pelatihan, seperti data pelatihan, hiperparameter, dan informasi konfigurasi lainnya, tersedia untuk wadah Docker Anda. 

Saat Anda mengirim [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)permintaan ke SageMaker AI untuk memulai pelatihan model, Anda menentukan jalur Amazon Elastic Container Registry (Amazon ECR) Registry ECR) dari image Docker yang berisi algoritme pelatihan. Anda juga menentukan lokasi Amazon Simple Storage Service (Amazon S3) tempat data pelatihan disimpan dan parameter khusus algoritme. SageMaker AI membuat informasi ini tersedia untuk wadah Docker sehingga algoritme pelatihan Anda dapat menggunakannya. Bagian ini menjelaskan bagaimana kami membuat informasi ini tersedia untuk wadah Docker Anda. Untuk informasi tentang membuat pekerjaan pelatihan, lihat`CreateTrainingJob`. Untuk informasi lebih lanjut tentang cara wadah SageMaker AI mengatur informasi, lihat[SageMaker Toolkit Pelatihan dan Inferensi](amazon-sagemaker-toolkits.md).

**Topics**
+ [

## Hyperparameter
](#your-algorithms-training-algo-running-container-hyperparameters)
+ [

## Variabel lingkungan
](#your-algorithms-training-algo-running-container-environment-variables)
+ [

## Konfigurasi Data Masukan
](#your-algorithms-training-algo-running-container-inputdataconfig)
+ [

## Data Pelatihan
](#your-algorithms-training-algo-running-container-trainingdata)
+ [

## Konfigurasi Pelatihan Terdistribusi
](#your-algorithms-training-algo-running-container-dist-training)

## Hyperparameter
<a name="your-algorithms-training-algo-running-container-hyperparameters"></a>

 SageMaker AI membuat hyperparameters dalam `CreateTrainingJob` permintaan tersedia di wadah Docker dalam file. `/opt/ml/input/config/hyperparameters.json`

Berikut ini adalah contoh konfigurasi hyperparameter `hyperparameters.json` untuk menentukan `num_round` dan `eta` hyperparameters dalam `CreateTrainingJob` operasi untuk. [XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) 

```
{
    "num_round": "128",
    "eta": "0.001"
}
```

Untuk daftar lengkap hiperparameter yang dapat digunakan untuk XGBoost algoritme bawaan SageMaker AI, lihat [XGBoostHyperparameters](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost_hyperparameters.html).

Hiperparameter yang dapat Anda atur bergantung pada algoritme yang Anda latih. Untuk daftar hiperparameter yang tersedia untuk algoritme bawaan SageMaker AI, temukan yang tercantum di **Hyperparameters** di bawah tautan algoritme di Gunakan Algoritma [Bawaan Amazon SageMaker AI atau Model Pra-terlatih](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).

## Variabel lingkungan
<a name="your-algorithms-training-algo-running-container-environment-variables"></a>

SageMaker AI menetapkan variabel lingkungan berikut dalam wadah Anda:
+ TRAINING\$1JOB\$1NAME - Ditentukan dalam parameter permintaan. `TrainingJobName` `CreateTrainingJob`
+ TRAINING\$1JOB\$1ARN — Nama Sumber Daya Amazon (ARN) dari pekerjaan pelatihan dikembalikan sebagai tanggapan. `TrainingJobArn` `CreateTrainingJob`
+ Semua variabel lingkungan ditentukan dalam parameter [Lingkungan](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-Environment) dalam `CreateTrainingJob` permintaan.

## Konfigurasi Data Masukan
<a name="your-algorithms-training-algo-running-container-inputdataconfig"></a>

SageMaker AI membuat informasi saluran data dalam `InputDataConfig` parameter dari `CreateTrainingJob` permintaan Anda tersedia di `/opt/ml/input/config/inputdataconfig.json` file di wadah Docker Anda.

Misalnya, Anda menentukan tiga saluran data (`train`,`evaluation`, dan`validation`) dalam permintaan Anda. SageMaker AI menyediakan JSON berikut:

```
{
  "train" : {"ContentType":  "trainingContentType",
             "TrainingInputMode": "File",
             "S3DistributionType": "FullyReplicated",
             "RecordWrapperType": "None"},
  "evaluation" : {"ContentType":  "evalContentType",
                  "TrainingInputMode": "File",
                  "S3DistributionType": "FullyReplicated",
                  "RecordWrapperType": "None"},
  "validation" : {"TrainingInputMode": "File",
                  "S3DistributionType": "FullyReplicated",
                  "RecordWrapperType": "None"}
}
```

**catatan**  
SageMaker AI hanya menyediakan informasi yang relevan tentang setiap saluran data (misalnya, nama saluran dan jenis konten) ke wadah, seperti yang ditunjukkan pada contoh sebelumnya. `S3DistributionType`akan diatur `FullyReplicated` seolah-olah Anda menentukan EFS atau FSx Lustre sebagai sumber data input.

## Data Pelatihan
<a name="your-algorithms-training-algo-running-container-trainingdata"></a>

`TrainingInputMode`Parameter dalam `AlgorithmSpecification` [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)permintaan menentukan bagaimana kumpulan data pelatihan tersedia untuk penampung Anda. Mode input berikut tersedia.
+ **`File`modus**

  Jika Anda menggunakan `File` mode sebagai `TrainingInputMode` nilai Anda, SageMaker AI menetapkan parameter berikut dalam wadah Anda.
  + `TrainingInputMode`Parameter Anda ditulis `inputdataconfig.json` sebagai “File”.
  + Direktori saluran data Anda ditulis ke`/opt/ml/input/data/channel_name`.

  Jika Anda menggunakan `File` mode, SageMaker AI membuat direktori untuk setiap saluran. Misalnya, jika Anda memiliki tiga saluran bernama`training`,`validation`, dan`testing`, SageMaker AI membuat tiga direktori berikut di wadah Docker Anda: 
  + `/opt/ml/input/data/training`
  + `/opt/ml/input/data/validation`
  + `/opt/ml/input/data/testing`

  `File`modus juga mendukung sumber data berikut.
  + Amazon Simple Storage Service (Amazon S3)
  + Amazon Elastic File System (Amazon EFS)
  + Amazon FSx untuk Lustre
**catatan**  
Saluran yang menggunakan sumber data sistem file seperti Amazon EFS dan Amazon FSx harus menggunakan `File` mode. Dalam hal ini, jalur direktori yang disediakan di saluran dipasang di`/opt/ml/input/data/channel_name`.
+ **`FastFile`modus**

  Jika Anda menggunakan `FastFile` mode sebagai milik Anda`TrainingInputNodeParameter`, SageMaker AI menetapkan parameter berikut di wadah Anda.
  + Mirip dengan `File` `FastFile` mode, dalam mode, `TrainingInputMode` parameter Anda ditulis `inputdataconfig.json` sebagai “File”.
  + Direktori saluran data Anda ditulis ke`/opt/ml/input/data/channel_name`.

  `FastFile`modus mendukung sumber data berikut.
  + Amazon S3

  Jika Anda menggunakan `FastFile` mode, direktori saluran dipasang dengan izin hanya-baca.

  Secara historis, `File` mode mendahului `FastFile` mode. Untuk memastikan kompatibilitas mundur, algoritme yang mendukung `File` mode juga dapat bekerja dengan mulus dengan `FastFile` mode selama `TrainingInputMode` parameter diatur ke dalam. `File` `inputdataconfig.json.`
**catatan**  
Saluran yang menggunakan `FastFile` mode harus menggunakan “S3Prefix”. `S3DataType`  
`FastFile`mode menyajikan tampilan folder yang menggunakan garis miring maju (`/`) sebagai pembatas untuk mengelompokkan objek Amazon S3 ke dalam folder. `S3Uri`awalan tidak harus sesuai dengan nama folder sebagian. Misalnya, jika kumpulan data Amazon S3 berisi`s3://amzn-s3-demo-bucket/train-01/data.csv`, maka `s3://amzn-s3-demo-bucket/train` tidak ada yang `s3://amzn-s3-demo-bucket/train-01` diizinkan sebagai awalan. `S3Uri`  
Garis miring ke depan disarankan untuk menentukan saluran yang sesuai dengan folder. Misalnya, `s3://amzn-s3-demo-bucket/train-01/` saluran untuk `train-01` folder. Tanpa garis miring ke depan, saluran akan menjadi ambigu jika ada folder atau file `s3://amzn-s3-demo-bucket/train-011/` lain. `s3://amzn-s3-demo-bucket/train-01.txt/`
+ **`Pipe`modus**
  + `TrainingInputMode`parameter ditulis ke`inputdataconfig.json`: “Pipa”
  + Direktori saluran data dalam wadah Docker: `/opt/ml/input/data/channel_name_epoch_number`
  + Sumber data yang didukung: Amazon S3

  Anda perlu membaca dari pipa terpisah untuk setiap saluran. Misalnya, jika Anda memiliki tiga saluran bernama`training`,`validation`, dan`testing`, Anda perlu membaca dari pipa berikut:
  + `/opt/ml/input/data/training_0, /opt/ml/input/data/training_1, ...`
  + `/opt/ml/input/data/validation_0, /opt/ml/input/data/validation_1, ...`
  + `/opt/ml/input/data/testing_0, /opt/ml/input/data/testing_1, ...`

  Baca pipa secara berurutan. Misalnya, jika Anda memiliki saluran yang disebut`training`, baca pipa dalam urutan ini: 

  1. Buka `/opt/ml/input/data/training_0` dalam mode baca dan baca ke end-of-file (EOF) atau, jika Anda selesai dengan epoch pertama, tutup file pipa lebih awal. 

  1. Setelah menutup file pipa pertama, cari `/opt/ml/input/data/training_1` dan baca sampai Anda menyelesaikan epoch kedua, dan seterusnya.

  Jika file untuk epoch tertentu belum ada, kode Anda mungkin perlu mencoba lagi sampai pipa dibuat Tidak ada batasan pengurutan di seluruh jenis saluran. Misalnya, Anda dapat membaca beberapa zaman untuk `training` saluran dan hanya mulai membaca `validation` saluran saat Anda siap. Atau, Anda dapat membacanya secara bersamaan jika algoritme Anda mengharuskannya.

  Untuk contoh notebook Jupyter yang menunjukkan cara menggunakan mode Pipa saat membawa wadah Anda sendiri, lihat Membawa [algoritme mode pipa Anda sendiri ke](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/pipe_bring_your_own/pipe_bring_your_own.ipynb) Amazon AI. SageMaker 

  

SageMaker Pelatihan model AI mendukung bucket direktori S3 Express One Zone berkinerja tinggi sebagai lokasi input data untuk mode file, mode file cepat, dan mode pipa. Untuk menggunakan S3 Express One Zone, masukkan lokasi bucket direktori S3 Express One Zone, bukan bucket tujuan umum Amazon S3. Berikan ARN untuk peran IAM dengan kontrol akses dan kebijakan izin yang diperlukan. Lihat [AmazonSageMakerFullAccesspolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html) untuk detailnya. Anda hanya dapat mengenkripsi data keluaran SageMaker AI di bucket direktori dengan enkripsi sisi server dengan kunci terkelola Amazon S3 (SSE-S3). Enkripsi sisi server dengan AWS KMS kunci (SSE-KMS) saat ini tidak didukung untuk menyimpan data keluaran SageMaker AI dalam bucket direktori. Untuk informasi selengkapnya, lihat [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html).

## Konfigurasi Pelatihan Terdistribusi
<a name="your-algorithms-training-algo-running-container-dist-training"></a>

Jika Anda melakukan pelatihan terdistribusi dengan banyak kontainer, SageMaker AI membuat informasi tentang semua kontainer tersedia dalam `/opt/ml/input/config/resourceconfig.json` file.

Untuk mengaktifkan komunikasi antar kontainer, file JSON ini berisi informasi untuk semua kontainer. SageMaker AI membuat file ini tersedia untuk algoritme `Pipe` mode `File` dan keduanya. File ini memberikan informasi berikut:
+ `current_host`—Nama kontainer saat ini di jaringan kontainer. Misalnya, `algo-1`. Nilai host dapat berubah kapan saja. Jangan menulis kode dengan nilai spesifik untuk variabel ini.
+ `hosts`—Daftar nama semua kontainer di jaringan kontainer, diurutkan secara leksikografis. Misalnya, `["algo-1", "algo-2", "algo-3"]` untuk cluster tiga simpul. Kontainer dapat menggunakan nama-nama ini untuk menangani kontainer lain di jaringan kontainer. Nilai host dapat berubah kapan saja. Jangan menulis kode dengan nilai spesifik untuk variabel-variabel ini.
+ `network_interface_name`—Nama antarmuka jaringan yang terpapar ke wadah Anda. Misalnya, kontainer yang menjalankan Message Passing Interface (MPI) dapat menggunakan informasi ini untuk mengatur nama antarmuka jaringan.
+ Jangan gunakan informasi di dalam `/etc/hostname` atau `/etc/hosts` karena mungkin tidak akurat.
+ Informasi nama host mungkin tidak segera tersedia untuk wadah algoritme. Sebaiknya tambahkan kebijakan coba lagi pada operasi resolusi nama host saat node tersedia di klaster.

Berikut ini adalah contoh file pada node 1 dalam cluster tiga node:

```
{
    "current_host": "algo-1",
    "hosts": ["algo-1","algo-2","algo-3"],
    "network_interface_name":"eth1"
}
```

# Jalankan Pelatihan dengan EFA
<a name="your-algorithms-training-efa"></a>

 SageMaker AI menyediakan integrasi dengan perangkat [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) untuk mempercepat aplikasi High Performance Computing (HPC) dan pembelajaran mesin. Integrasi ini memungkinkan Anda memanfaatkan perangkat EFA saat menjalankan pekerjaan pelatihan terdistribusi Anda. Anda dapat menambahkan integrasi EFA ke wadah Docker yang ada yang Anda bawa ke SageMaker AI. Informasi berikut menguraikan cara mengonfigurasi kontainer Anda sendiri untuk menggunakan perangkat EFA untuk pekerjaan pelatihan terdistribusi Anda. 

## Prasyarat
<a name="your-algorithms-training-efa-prereq"></a>

 Wadah Anda harus memenuhi [spesifikasi wadah SageMaker Pelatihan](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-dockerfile.html).  

## Instal EFA dan paket yang diperlukan
<a name="your-algorithms-training-efa-install"></a>

Wadah Anda harus mengunduh dan menginstal [perangkat lunak EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html). Ini memungkinkan penampung Anda mengenali perangkat EFA, dan menyediakan versi Libfabric dan Open MPI yang kompatibel. 

Alat apa pun seperti MPI dan NCCL harus diinstal dan dikelola di dalam wadah untuk digunakan sebagai bagian dari pekerjaan pelatihan yang mendukung EFA Anda. Untuk daftar semua versi EFA yang tersedia, lihat [Verifikasi penginstal EFA menggunakan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-verify.html) checksum. Contoh berikut menunjukkan cara memodifikasi Dockerfile wadah berkemampuan EFA Anda untuk menginstal EFA, MPI, OFI, NCCL, dan NCCL-TEST.

**catatan**  
Saat menggunakan PyTorch dengan EFA pada penampung Anda, versi NCCL wadah Anda harus cocok dengan versi NCCL instalasi Anda. PyTorch Untuk memverifikasi versi PyTorch NCCL, gunakan perintah berikut:  

```
torch.cuda.nccl.version()
```

```
ARG OPEN_MPI_PATH=/opt/amazon/openmpi/
ENV NCCL_VERSION=2.7.8
ENV EFA_VERSION=1.30.0
ENV BRANCH_OFI=1.1.1

#################################################
## EFA and MPI SETUP
RUN cd $HOME \
  && curl -O https://s3-us-west-2.amazonaws.com/aws-efa-installer/aws-efa-installer-${EFA_VERSION}.tar.gz \
  && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
  && cd aws-efa-installer \
  && ./efa_installer.sh -y --skip-kmod -g \

ENV PATH="$OPEN_MPI_PATH/bin:$PATH"
ENV LD_LIBRARY_PATH="$OPEN_MPI_PATH/lib/:$LD_LIBRARY_PATH"

#################################################
## NCCL, OFI, NCCL-TEST SETUP
RUN cd $HOME \
  && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
  && cd nccl \
  && make -j64 src.build BUILDDIR=/usr/local

RUN apt-get update && apt-get install -y autoconf
RUN cd $HOME \
  && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
  && cd aws-ofi-nccl \
  && ./autogen.sh \
  && ./configure --with-libfabric=/opt/amazon/efa \
       --with-mpi=/opt/amazon/openmpi \
       --with-cuda=/usr/local/cuda \
       --with-nccl=/usr/local --prefix=/usr/local \
  && make && make install
  
RUN cd $HOME \
  && git clone https://github.com/NVIDIA/nccl-tests \
  && cd nccl-tests \
  && make MPI=1 MPI_HOME=/opt/amazon/openmpi CUDA_HOME=/usr/local/cuda NCCL_HOME=/usr/local
```

## Pertimbangan saat membuat wadah Anda
<a name="your-algorithms-training-efa-considerations"></a>

Perangkat EFA dipasang ke wadah seperti `/dev/infiniband/uverbs0` di bawah daftar perangkat yang dapat diakses ke wadah. Pada instance P4d, wadah memiliki akses ke 4 perangkat EFA. Perangkat EFA dapat ditemukan dalam daftar perangkat yang dapat diakses ke wadah sebagai: 
+  `/dev/infiniband/uverbs0` 
+  `/dev/infiniband/uverbs1` 
+  `/dev/infiniband/uverbs2` 
+  `/dev/infiniband/uverbs3` 

 [Untuk mendapatkan informasi tentang nama host, nama host peer, dan antarmuka jaringan (untuk MPI) dari `resourceconfig.json` file yang disediakan untuk setiap instance kontainer, lihat Konfigurasi Pelatihan Terdistribusi.](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training) Container Anda menangani lalu lintas TCP reguler antar rekan melalui Elastic Network Interfaces (ENI) default, sambil menangani lalu lintas OFI (kernel bypass) melalui perangkat EFA. 

## Verifikasi bahwa perangkat EFA Anda dikenali
<a name="your-algorithms-training-efa-verify"></a>

  Untuk memverifikasi bahwa perangkat EFA dikenali, jalankan perintah berikut dari dalam container Anda. 

```
/opt/amazon/efa/bin/fi_info -p efa
```

Output-nya semestinya mirip dengan yang berikut.

```
provider: efa
    fabric: EFA-fe80::e5:56ff:fe34:56a8
    domain: efa_0-rdm
    version: 2.0
    type: FI_EP_RDM
    protocol: FI_PROTO_EFA
provider: efa
    fabric: EFA-fe80::e5:56ff:fe34:56a8
    domain: efa_0-dgrm
    version: 2.0
    type: FI_EP_DGRAM
    protocol: FI_PROTO_EFA
provider: efa;ofi_rxd
    fabric: EFA-fe80::e5:56ff:fe34:56a8
    domain: efa_0-dgrm
    version: 1.0
    type: FI_EP_RDM
    protocol: FI_PROTO_RXD
```

## Menjalankan pekerjaan pelatihan dengan EFA
<a name="your-algorithms-training-efa-run"></a>

 Setelah Anda membuat wadah berkemampuan EFA, Anda dapat menjalankan pekerjaan pelatihan dengan EFA menggunakan SageMaker AI Estimator dengan cara yang sama seperti yang Anda lakukan dengan gambar Docker lainnya. Untuk informasi lebih lanjut tentang mendaftarkan kontainer Anda dan menggunakannya untuk pelatihan, lihat [Mengadaptasi Wadah Pelatihan Anda Sendiri](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step5).

# Bagaimana Amazon SageMaker AI Sinyal Algoritma Sukses dan Kegagalan
<a name="your-algorithms-training-signal-success-failure"></a>

Algoritma pelatihan menunjukkan apakah berhasil atau gagal menggunakan kode keluar dari prosesnya. 

Eksekusi pelatihan yang berhasil harus keluar dengan kode keluar 0 dan eksekusi pelatihan yang gagal harus keluar dengan kode keluar bukan nol. Ini akan dikonversi ke `Completed` dan `Failed` `TrainingJobStatus` dikembalikan oleh`DescribeTrainingJob`. Konvensi kode keluar ini standar dan mudah diimplementasikan dalam semua bahasa. Misalnya, dengan Python, Anda dapat menggunakan `sys.exit(1)` sinyal kegagalan keluar, dan hanya berjalan ke akhir rutinitas utama akan menyebabkan Python keluar dengan kode 0.

Dalam kasus kegagalan, algoritma dapat menulis deskripsi kegagalan pada file kegagalan. Lihat bagian selanjutnya untuk detailnya.

# Bagaimana Amazon SageMaker AI Memproses Output Pelatihan
<a name="your-algorithms-training-algo-output"></a>

Saat algoritme Anda berjalan dalam wadah, itu menghasilkan output termasuk status pekerjaan pelatihan dan model dan artefak keluaran. Algoritma Anda harus menulis informasi ini ke file-file berikut, yang terletak di `/output` direktori container. Amazon SageMaker AI memproses informasi yang terkandung dalam direktori ini sebagai berikut:
+ `/opt/ml/model`— Algoritma Anda harus menulis semua artefak model akhir ke direktori ini. SageMaker AI menyalin data ini sebagai objek tunggal dalam format tar terkompresi ke lokasi S3 yang Anda tentukan dalam permintaan. `CreateTrainingJob` Jika beberapa kontainer dalam satu pekerjaan pelatihan menulis ke direktori ini, mereka harus memastikan tidak ada `file/directory` nama yang berbenturan. SageMaker AI mengumpulkan hasilnya dalam file TAR dan mengunggah ke S3 di akhir pekerjaan pelatihan. 
+ `/opt/ml/output/data`— Algoritma Anda harus menulis artefak yang ingin Anda simpan selain model akhir ke direktori ini. SageMaker AI menyalin data ini sebagai objek tunggal dalam format tar terkompresi ke lokasi S3 yang Anda tentukan dalam permintaan. `CreateTrainingJob` Jika beberapa kontainer dalam satu pekerjaan pelatihan menulis ke direktori ini, mereka harus memastikan tidak ada `file/directory` nama yang berbenturan. SageMaker AI mengumpulkan hasilnya dalam file TAR dan mengunggah ke S3 di akhir pekerjaan pelatihan.
+ `/opt/ml/output/failure`— Jika pelatihan gagal, setelah semua output algoritma (misalnya, logging) selesai, algoritme Anda harus menulis deskripsi kegagalan ke file ini. Sebagai `DescribeTrainingJob` tanggapan, SageMaker AI mengembalikan 1024 karakter pertama dari file ini sebagai`FailureReason`. 

Anda dapat menentukan bucket direktori tujuan umum S3 atau S3 untuk menyimpan output pelatihan Anda. Bucket direktori hanya menggunakan kelas penyimpanan Amazon S3 Express One Zone, yang dirancang untuk beban kerja atau aplikasi penting kinerja yang memerlukan latensi milidetik satu digit yang konsisten. Pilih jenis bucket yang paling sesuai dengan aplikasi dan persyaratan kinerja Anda. Untuk informasi selengkapnya tentang bucket direktori S3, lihat [Bucket direktori](https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html) di Panduan Pengguna *Layanan Penyimpanan Sederhana Amazon*. 

**catatan**  
Anda hanya dapat mengenkripsi data keluaran SageMaker AI di bucket direktori S3 dengan enkripsi sisi server dengan kunci terkelola Amazon S3 (SSE-S3). Enkripsi sisi server dengan AWS KMS kunci (SSE-KMS) saat ini tidak didukung untuk menyimpan data keluaran SageMaker AI di bucket direktori.