Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# SageMaker HyperPod resep
SageMaker HyperPod Resep Amazon adalah tumpukan pelatihan pra-konfigurasi yang disediakan oleh AWS untuk membantu Anda memulai pelatihan dengan cepat dan menyempurnakan model fondasi yang tersedia untuk umum (FMs) dari berbagai keluarga model seperti Llama, Mistral, Mixtral, atau. DeepSeek Resep mengotomatiskan loop end-to-end pelatihan, termasuk memuat kumpulan data, menerapkan teknik pelatihan terdistribusi, dan mengelola pos pemeriksaan untuk pemulihan yang lebih cepat dari kesalahan.
SageMaker HyperPod resep sangat bermanfaat bagi pengguna yang mungkin tidak memiliki keahlian pembelajaran mesin yang mendalam, karena mereka mengabstraksikan banyak kompleksitas yang terlibat dalam pelatihan model besar.
Anda dapat menjalankan resep di dalam SageMaker HyperPod atau sebagai pekerjaan SageMaker pelatihan.
Tabel berikut disimpan dalam SageMaker HyperPod GitHub repositori dan memberikan up-to-date informasi paling banyak tentang model yang didukung untuk pra-pelatihan dan fine-tuning, resep masing-masing dan skrip peluncuran, jenis instans yang didukung, dan banyak lagi.
+ Untuk daftar terbaru dari model, resep, dan skrip peluncuran yang didukung untuk pra-pelatihan, lihat tabel [pra-pelatihan](https://github.com/aws/sagemaker-hyperpod-recipes?tab=readme-ov-file#pre-training).
+ [Untuk daftar terbaru model, resep, dan skrip peluncuran yang didukung untuk fine-tuning, lihat tabel fine-tuning.](https://github.com/aws/sagemaker-hyperpod-recipes?tab=readme-ov-file#fine-tuning)
Bagi SageMaker HyperPod pengguna, otomatisasi alur kerja end-to-end pelatihan berasal dari integrasi adaptor pelatihan dengan SageMaker HyperPod resep. Adaptor pelatihan dibangun di atas [ NeMo kerangka kerja NVIDIA dan paket](https://docs.nvidia.com/nemo-framework/user-guide/latest/overview.html) [Pelatihan Terdistribusi Neuronx](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/libraries/neuronx-distributed/index.html). Jika Anda terbiasa menggunakan NeMo, proses menggunakan adaptor pelatihan adalah sama. Adaptor pelatihan menjalankan resep di cluster Anda.
![\[Diagram yang menunjukkan alur kerja SageMaker HyperPod resep. Ikon “Resep” di bagian atas dimasukkan ke dalam kotak "peluncur HyperPod resep”. Kotak ini terhubung ke bagian yang lebih besar berlabel “Cluster: Slurm, K8s,...” yang berisi tiga ikon GPU dengan file resep terkait. Bagian bawah bagian cluster diberi label “Train with HyperPod Training Adapter”.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/sagemaker-hyperpod-recipes-overview.png)
Anda juga dapat melatih model Anda sendiri dengan mendefinisikan resep khusus Anda sendiri.
Untuk memulai dengan tutorial, lihat[Tutorial](sagemaker-hyperpod-recipes-tutorials.md).
**Topics**
+ [Tutorial](sagemaker-hyperpod-recipes-tutorials.md)
+ [Konfigurasi default](default-configurations.md)
+ [Konfigurasi khusus cluster](cluster-specific-configurations.md)
+ [Pertimbangan-pertimbangan](cluster-specific-configurations-special-considerations.md)
+ [Pengaturan lanjutan](cluster-specific-configurations-advanced-settings.md)
+ [Lampiran](appendix.md)
# Tutorial
Tutorial mulai cepat berikut membantu Anda memulai menggunakan resep untuk pelatihan:
+ SageMaker HyperPod dengan Orkestrasi Slurm
+ Pra-pelatihan
+ [HyperPod Tutorial pra-pelatihan klaster slurm (GPU)](hyperpod-gpu-slurm-pretrain-tutorial.md)
+ [Tutorial pra-pelatihan cluster Trainium Slurm](hyperpod-trainium-slurm-cluster-pretrain-tutorial.md)
+ Penyetelan halus
+ [HyperPod Tutorial Peft-LoRa cluster slurm (GPU)](hyperpod-gpu-slurm-peft-lora-tutorial.md)
+ [HyperPod Tutorial DPO klaster slurm (GPU)](hyperpod-gpu-slurm-dpo-tutorial.md)
+ SageMaker HyperPod dengan Orkestrasi K8s
+ Pra-pelatihan
+ [Tutorial pra-pelatihan klaster Kubernetes (GPU)](sagemaker-hyperpod-gpu-kubernetes-cluster-pretrain-tutorial.md)
+ [Tutorial SageMaker pra-pelatihan pekerjaan pelatihan trainium](sagemaker-hyperpod-trainium-sagemaker-training-jobs-pretrain-tutorial.md)
+ SageMaker Lowongan Training
+ Pra-pelatihan
+ [SageMaker pelatihan pekerjaan pra-pelatihan tutorial (GPU)](sagemaker-hyperpod-gpu-sagemaker-training-jobs-pretrain-tutorial.md)
+ [Tutorial SageMaker pra-pelatihan pekerjaan pelatihan trainium](sagemaker-hyperpod-trainium-sagemaker-training-jobs-pretrain-tutorial.md)
# HyperPod Tutorial pra-pelatihan klaster slurm (GPU)
Tutorial berikut mengatur lingkungan Slurm dan memulai pekerjaan pelatihan pada model parameter Llama 8 miliar.
**Prasyarat**
Sebelum Anda mulai mengatur lingkungan Anda untuk menjalankan resep, pastikan Anda memiliki:
Siapkan cluster HyperPod GPU Slurm.
Cluster HyperPod Slurm Anda harus mengaktifkan Nvidia Enroot dan Pyxis (ini diaktifkan secara default).
Lokasi penyimpanan bersama. Ini bisa berupa sistem FSx file Amazon atau sistem NFS yang dapat diakses dari node cluster.
Data dalam salah satu format berikut:
JSON
JSONGZ (JSON Terkompresi)
PANAH
(Opsional) Anda harus mendapatkan HuggingFace token jika Anda menggunakan bobot model HuggingFace untuk pra-pelatihan atau fine-tuning. Untuk informasi selengkapnya tentang mendapatkan token, lihat [Token akses pengguna](https://huggingface.co/docs/hub/en/security-tokens).
## HyperPod Pengaturan lingkungan GPU Slurm
Untuk memulai pekerjaan pelatihan pada cluster HyperPod GPU Slurm, lakukan hal berikut:
1. SSH ke node kepala cluster Slurm Anda.
1. Setelah Anda masuk, atur lingkungan virtual. Pastikan Anda menggunakan Python 3.9 atau lebih tinggi.
```
#set up a virtual environment
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
1. Kloning SageMaker HyperPod resep dan repositori SageMaker HyperPod adaptor ke lokasi penyimpanan bersama.
```
git clone https://github.com/aws/sagemaker-hyperpod-training-adapter-for-nemo.git
git clone --recursive https://github.com/aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
1. Buat file squash menggunakan Enroot. Untuk menemukan rilis terbaru dari wadah SMP, lihat[Catatan rilis untuk pustaka paralelisme SageMaker model](model-parallel-release-notes.md). Untuk mendapatkan pemahaman yang lebih dalam tentang cara menggunakan file Enroot, lihat [Build AWS-optimized Nemo-Launcher](https://github.com/aws-samples/awsome-distributed-training/tree/main/3.test_cases/2.nemo-launcher#2-build-aws-optimized-nemo-launcher-image) image.
```
REGION=""
IMAGE="658645717510.dkr.ecr.${REGION}.amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121"
aws ecr get-login-password --region ${REGION} | docker login --username AWS --password-stdin 658645717510.dkr.ecr.${REGION}.amazonaws.com
enroot import -o $PWD/smdistributed-modelparallel.sqsh dockerd://${IMAGE}
mv $PWD/smdistributed-modelparallel.sqsh "/fsx/"
```
1. Untuk menggunakan file squash Enroot untuk memulai pelatihan, gunakan contoh berikut untuk memodifikasi file. `recipes_collection/config.yaml`
```
container: /fsx/path/to/your/smdistributed-modelparallel.sqsh
```
## Luncurkan pekerjaan pelatihan
Setelah Anda menginstal dependensi, mulai pekerjaan pelatihan dari direktori. `sagemaker-hyperpod-recipes/launcher_scripts` [Anda mendapatkan dependensi dengan mengkloning repositori resep: SageMaker HyperPod ](https://github.com/aws/sagemaker-hyperpod-recipes)
Pertama, pilih resep pelatihan Anda dari Github, nama model ditentukan sebagai bagian dari resep. Kami menggunakan `launcher_scripts/llama/run_hf_llama3_8b_seq16k_gpu_p5x16_pretrain.sh` skrip untuk meluncurkan Llama 8b dengan panjang urutan 8192 resep pra-pelatihan,`llama/hf_llama3_8b_seq16k_gpu_p5x16_pretrain`, dalam contoh berikut.
+ `IMAGE`: Wadah dari bagian pengaturan lingkungan.
+ (Opsional) Anda dapat memberikan HuggingFace token jika Anda membutuhkan bobot yang telah dilatih sebelumnya HuggingFace dengan menetapkan pasangan nilai kunci berikut:
```
recipes.model.hf_access_token=
```
```
#!/bin/bash
IMAGE="${YOUR_IMAGE}"
SAGEMAKER_TRAINING_LAUNCHER_DIR="${SAGEMAKER_TRAINING_LAUNCHER_DIR:-${PWD}}"
TRAIN_DIR="${YOUR_TRAIN_DIR}" # Location of training dataset
VAL_DIR="${YOUR_VAL_DIR}" # Location of validation dataset
# experiment ouput directory
EXP_DIR="${YOUR_EXP_DIR}"
HYDRA_FULL_ERROR=1 python3 "${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py" \
recipes=training/llama/hf_llama3_8b_seq16k_gpu_p5x16_pretrain \
base_results_dir="${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results" \
recipes.run.name="hf_llama3_8b" \
recipes.exp_manager.exp_dir="$EXP_DIR" \
recipes.model.data.train_dir="$TRAIN_DIR" \
recipes.model.data.val_dir="$VAL_DIR" \
container="${IMAGE}" \
+cluster.container_mounts.0="/fsx:/fsx"
```
Setelah Anda mengkonfigurasi semua parameter yang diperlukan dalam skrip peluncur, Anda dapat menjalankan skrip menggunakan perintah berikut.
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq16k_gpu_p5x16_pretrain.sh
```
Untuk informasi selengkapnya tentang konfigurasi cluster Slurm, lihat. [Menjalankan pekerjaan pelatihan di HyperPod Slurm](cluster-specific-configurations-run-training-job-hyperpod-slurm.md)
# Tutorial pra-pelatihan cluster Trainium Slurm
Tutorial berikut menyiapkan lingkungan Trainium pada cluster Slurm dan memulai pekerjaan pelatihan pada model parameter Llama 8 miliar.
**Prasyarat**
Sebelum Anda mulai mengatur lingkungan Anda, pastikan Anda memiliki:
Siapkan cluster SageMaker HyperPod Trainium Slurm.
Lokasi penyimpanan bersama. Ini bisa berupa sistem FSx file Amazon atau sistem NFS yang dapat diakses dari node cluster.
Data dalam salah satu format berikut:
JSON
JSONGZ (JSON Terkompresi)
PANAH
(Opsional) Anda harus mendapatkan HuggingFace token jika Anda menggunakan bobot model HuggingFace untuk pra-pelatihan atau fine-tuning. Untuk informasi selengkapnya tentang mendapatkan token, lihat [Token akses pengguna](https://huggingface.co/docs/hub/en/security-tokens).
## Siapkan lingkungan Trainium di Slurm Cluster
Untuk memulai pekerjaan pelatihan di cluster Slurm, lakukan hal berikut:
+ SSH ke node kepala cluster Slurm Anda.
+ Setelah Anda masuk, atur lingkungan Neuron. Untuk informasi tentang pengaturan Neuron, lihat [Langkah pengaturan neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/libraries/nxd-training/tutorials/hf_llama3_8B_SFT.html#setting-up-the-environment). Kami merekomendasikan untuk mengandalkan Deep learning AMI yang sudah diinstal sebelumnya dengan driver Neuron, seperti [Ubuntu 20 dengan DLAMI](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/general/setup/neuron-setup/pytorch/neuronx/ubuntu/torch-neuronx-ubuntu20-pytorch-dlami.html#setup-torch-neuronx-ubuntu20-dlami-pytorch) Pytorch.
+ Kloning repositori SageMaker HyperPod resep ke lokasi penyimpanan bersama di cluster. Lokasi penyimpanan bersama dapat berupa sistem FSx file Amazon atau sistem NFS yang dapat diakses dari node cluster.
```
git clone --recursive https://github.com/aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
+ Ikuti tutorial berikut: [HuggingFace Llama3-8B](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/libraries/nxd-training/tutorials/hf_llama3_8B_pretraining.html#) Pretraining
+ Siapkan konfigurasi model. Konfigurasi model tersedia di repo Neuron. Untuk konfigurasi model yang digunakan dalam tutorial ini, lihat konfigurasi model [llama3 8b](https://github.com/aws-neuron/neuronx-distributed/blob/main/examples/training/llama/tp_zero1_llama_hf_pretrain/8B_config_llama3/config.json)
## Luncurkan pekerjaan pelatihan di Trainium
Untuk meluncurkan pekerjaan pelatihan di Trainium, tentukan konfigurasi cluster dan resep Neuron. Misalnya, untuk meluncurkan pekerjaan pra-pelatihan llama3 8b di Trainium, atur skrip peluncuran, ke yang berikut: `launcher_scripts/llama/run_hf_llama3_8b_seq8k_trn1x4_pretrain.sh`
+ `MODEL_CONFIG`: Konfigurasi model dari bagian pengaturan lingkungan
+ (Opsional) Anda dapat memberikan HuggingFace token jika Anda membutuhkan bobot yang telah dilatih sebelumnya HuggingFace dengan menetapkan pasangan nilai kunci berikut:
```
recipes.model.hf_access_token=
```
```
#!/bin/bash
#Users should set up their cluster type in /recipes_collection/config.yaml
SAGEMAKER_TRAINING_LAUNCHER_DIR=${SAGEMAKER_TRAINING_LAUNCHER_DIR:-"$(pwd)"}
COMPILE=0
TRAIN_DIR="${TRAIN_DIR}" # Location of training dataset
MODEL_CONFIG="${MODEL_CONFIG}" # Location of config.json for the model
HYDRA_FULL_ERROR=1 python3 "${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py" \
base_results_dir="${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results" \
instance_type="trn1.32xlarge" \
recipes.run.compile="$COMPILE" \
recipes.run.name="hf-llama3-8b" \
recipes.trainer.num_nodes=4 \
recipes=training/llama/hf_llama3_8b_seq8k_trn1x4_pretrain \
recipes.data.train_dir="$TRAIN_DIR" \
recipes.model.model_config="$MODEL_CONFIG"
```
Untuk meluncurkan pekerjaan pelatihan, jalankan perintah berikut:
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq8k_trn1x4_pretrain.sh
```
Untuk informasi selengkapnya tentang konfigurasi cluster Slurm, lihat. [Menjalankan pekerjaan pelatihan di HyperPod Slurm](cluster-specific-configurations-run-training-job-hyperpod-slurm.md)
# HyperPod Tutorial DPO klaster slurm (GPU)
Tutorial berikut menyiapkan lingkungan Slurm dan memulai pekerjaan optimasi preferensi langsung (DPO) pada model parameter Llama 8 miliar.
**Prasyarat**
Sebelum Anda mulai mengatur lingkungan Anda, pastikan Anda memiliki:
Siapkan cluster HyperPod GPU Slurm
Cluster HyperPod Slurm Anda harus mengaktifkan Nvidia Enroot dan Pyxis (ini diaktifkan secara default).
Lokasi penyimpanan bersama. Ini bisa berupa sistem FSx file Amazon atau sistem NFS yang dapat diakses dari node cluster.
Dataset preferensi biner tokenized dalam salah satu format berikut:
JSON
JSONGZ (JSON Terkompresi)
PANAH
(Opsional) Jika Anda memerlukan bobot yang telah dilatih sebelumnya dari HuggingFace atau jika Anda melatih model Llama 3.2, Anda harus mendapatkan HuggingFace token sebelum memulai pelatihan. Untuk informasi selengkapnya tentang mendapatkan token, lihat [Token akses pengguna](https://huggingface.co/docs/hub/en/security-tokens).
## Siapkan lingkungan HyperPod GPU Slurm
Untuk memulai pekerjaan pelatihan di cluster Slurm, lakukan hal berikut:
+ SSH ke node kepala cluster Slurm Anda.
+ Setelah Anda masuk, atur lingkungan virtual. Pastikan Anda menggunakan Python 3.9 atau lebih tinggi.
```
#set up a virtual environment
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
+ Kloning SageMaker HyperPod resep dan repositori SageMaker HyperPod adaptor ke lokasi penyimpanan bersama. Lokasi penyimpanan bersama dapat berupa sistem FSx file Amazon atau sistem NFS yang dapat diakses dari node cluster.
```
git clone https://github.com/aws/sagemaker-hyperpod-training-adapter-for-nemo.git
git clone --recursive https://github.com/aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
+ Buat file squash menggunakan Enroot. Untuk menemukan rilis terbaru dari wadah SMP, lihat[Catatan rilis untuk pustaka paralelisme SageMaker model](model-parallel-release-notes.md). Untuk informasi selengkapnya tentang penggunaan file Enroot, lihat Gambar [AWS Nemo-Launcher yang dioptimalkan untuk membangun](https://github.com/aws-samples/awsome-distributed-training/tree/main/3.test_cases/2.nemo-launcher#2-build-aws-optimized-nemo-launcher-image).
```
REGION=""
IMAGE="658645717510.dkr.ecr.${REGION}.amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121"
aws ecr get-login-password --region ${REGION} | docker login --username AWS --password-stdin 658645717510.dkr.ecr.${REGION}.amazonaws.com
enroot import -o $PWD/smdistributed-modelparallel.sqsh dockerd://${IMAGE}
mv $PWD/smdistributed-modelparallel.sqsh "/fsx/"
```
+ Untuk menggunakan file squash Enroot untuk memulai pelatihan, gunakan contoh berikut untuk memodifikasi file. `recipes_collection/config.yaml`
```
container: /fsx/path/to/your/smdistributed-modelparallel.sqsh
```
## Luncurkan pekerjaan pelatihan
Untuk meluncurkan pekerjaan DPO untuk model parameter Llama 8 miliar dengan panjang urutan 8192 pada satu simpul komputasi Slurm, atur skrip peluncuran, ke yang berikut: `launcher_scripts/llama/run_hf_llama3_8b_seq8k_gpu_dpo.sh`
+ `IMAGE`: Wadah dari bagian pengaturan lingkungan.
+ `HF_MODEL_NAME_OR_PATH`: Tentukan nama atau jalur bobot yang telah dilatih sebelumnya dalam parameter hf\$1model\$1name\$1or\$1path resep.
+ (Opsional) Anda dapat memberikan HuggingFace token jika Anda membutuhkan bobot yang telah dilatih sebelumnya HuggingFace dengan menetapkan pasangan nilai kunci berikut:
```
recipes.model.hf_access_token=${HF_ACCESS_TOKEN}
```
**catatan**
Model referensi yang digunakan untuk DPO dalam pengaturan ini secara otomatis diturunkan dari model dasar yang dilatih (tidak ada model referensi terpisah yang didefinisikan secara eksplisit). Hyperparameter spesifik DPO telah dikonfigurasi sebelumnya dengan nilai default berikut:
`beta`: 0.1 (mengontrol kekuatan regularisasi divergensi KL)
`label_smoothing`: 0.0 (tidak ada perataan yang diterapkan pada label preferensi)
```
recipes.dpo.beta=${BETA}
recipes.dpo.label_smoothing=${LABEL_SMOOTHING}
```
```
#!/bin/bash
IMAGE="${YOUR_IMAGE}"
SAGEMAKER_TRAINING_LAUNCHER_DIR="${SAGEMAKER_TRAINING_LAUNCHER_DIR:-${PWD}}"
TRAIN_DIR="${YOUR_TRAIN_DIR}" # Location of training dataset
VAL_DIR="${YOUR_VAL_DIR}" # Location of validation dataset
# experiment output directory
EXP_DIR="${YOUR_EXP_DIR}"
HF_ACCESS_TOKEN="${YOUR_HF_TOKEN}"
HF_MODEL_NAME_OR_PATH="${HF_MODEL_NAME_OR_PATH}"
BETA="${BETA}"
LABEL_SMOOTHING="${LABEL_SMOOTHING}"
# Add hf_model_name_or_path and turn off synthetic_data
HYDRA_FULL_ERROR=1 python3 ${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py \
recipes=fine-tuning/llama/hf_llama3_8b_seq8k_gpu_dpo \
base_results_dir=${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results \
recipes.run.name="hf_llama3_dpo" \
recipes.exp_manager.exp_dir="$EXP_DIR" \
recipes.model.data.train_dir="$TRAIN_DIR" \
recipes.model.data.val_dir="$VAL_DIR" \
recipes.model.hf_model_name_or_path="$HF_MODEL_NAME_OR_PATH" \
container="${IMAGE}" \
+cluster.container_mounts.0="/fsx:/fsx" \
recipes.model.hf_access_token="${HF_ACCESS_TOKEN}" \
recipes.dpo.enabled=true \
recipes.dpo.beta="${BETA}" \
recipes.dpo.label_smoothing="${LABEL_SMOOTHING}$" \
```
Setelah Anda mengonfigurasi semua parameter yang diperlukan dalam skrip sebelumnya, Anda dapat memulai pekerjaan pelatihan dengan menjalankannya.
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq8k_gpu_dpo.sh
```
Untuk informasi selengkapnya tentang konfigurasi cluster Slurm, lihat. [Menjalankan pekerjaan pelatihan di HyperPod Slurm](cluster-specific-configurations-run-training-job-hyperpod-slurm.md)
# HyperPod Tutorial Peft-LoRa cluster slurm (GPU)
Tutorial berikut mengatur lingkungan Slurm dan memulai pekerjaan fine-tuning (PEFT) yang efisien parameter pada model parameter Llama 8 miliar.
**Prasyarat**
Sebelum Anda mulai mengatur lingkungan Anda, pastikan Anda memiliki:
Siapkan cluster HyperPod GPU Slurm
Cluster HyperPod Slurm Anda harus mengaktifkan Nvidia Enroot dan Pyxis (ini diaktifkan secara default).
Lokasi penyimpanan bersama. Ini bisa berupa sistem FSx file Amazon atau sistem NFS yang dapat diakses dari node cluster.
Data dalam salah satu format berikut:
JSON
JSONGZ (JSON Terkompresi)
PANAH
(Opsional) Jika Anda memerlukan bobot yang telah dilatih sebelumnya dari HuggingFace atau jika Anda melatih model Llama 3.2, Anda harus mendapatkan HuggingFace token sebelum memulai pelatihan. Untuk informasi selengkapnya tentang mendapatkan token, lihat [Token akses pengguna](https://huggingface.co/docs/hub/en/security-tokens).
## Siapkan lingkungan HyperPod GPU Slurm
Untuk memulai pekerjaan pelatihan di cluster Slurm, lakukan hal berikut:
+ SSH ke node kepala cluster Slurm Anda.
+ Setelah Anda masuk, atur lingkungan virtual. Pastikan Anda menggunakan Python 3.9 atau lebih tinggi.
```
#set up a virtual environment
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
+ Kloning SageMaker HyperPod resep dan repositori SageMaker HyperPod adaptor ke lokasi penyimpanan bersama. Lokasi penyimpanan bersama dapat berupa sistem FSx file Amazon atau sistem NFS yang dapat diakses dari node cluster.
```
git clone https://github.com/aws/sagemaker-hyperpod-training-adapter-for-nemo.git
git clone --recursive https://github.com/aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
+ Buat file squash menggunakan Enroot. Untuk menemukan rilis terbaru dari wadah SMP, lihat[Catatan rilis untuk pustaka paralelisme SageMaker model](model-parallel-release-notes.md). Untuk informasi selengkapnya tentang penggunaan file Enroot, lihat Gambar [AWS Nemo-Launcher yang dioptimalkan untuk membangun](https://github.com/aws-samples/awsome-distributed-training/tree/main/3.test_cases/2.nemo-launcher#2-build-aws-optimized-nemo-launcher-image).
```
REGION=""
IMAGE="658645717510.dkr.ecr.${REGION}.amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121"
aws ecr get-login-password --region ${REGION} | docker login --username AWS --password-stdin 658645717510.dkr.ecr.${REGION}.amazonaws.com
enroot import -o $PWD/smdistributed-modelparallel.sqsh dockerd://${IMAGE}
mv $PWD/smdistributed-modelparallel.sqsh "/fsx/"
```
+ Untuk menggunakan file squash Enroot untuk memulai pelatihan, gunakan contoh berikut untuk memodifikasi file. `recipes_collection/config.yaml`
```
container: /fsx/path/to/your/smdistributed-modelparallel.sqsh
```
## Luncurkan pekerjaan pelatihan
Untuk meluncurkan pekerjaan PEFT untuk model parameter Llama 8 miliar dengan panjang urutan 8192 pada satu simpul komputasi Slurm, atur skrip peluncuran, ke yang berikut: `launcher_scripts/llama/run_hf_llama3_8b_seq8k_gpu_lora.sh`
+ `IMAGE`: Wadah dari bagian pengaturan lingkungan.
+ `HF_MODEL_NAME_OR_PATH`: Tentukan nama atau jalur bobot yang telah dilatih sebelumnya dalam parameter hf\$1model\$1name\$1or\$1path resep.
+ (Opsional) Anda dapat memberikan HuggingFace token jika Anda membutuhkan bobot yang telah dilatih sebelumnya HuggingFace dengan menetapkan pasangan nilai kunci berikut:
```
recipes.model.hf_access_token=${HF_ACCESS_TOKEN}
```
```
#!/bin/bash
IMAGE="${YOUR_IMAGE}"
SAGEMAKER_TRAINING_LAUNCHER_DIR="${SAGEMAKER_TRAINING_LAUNCHER_DIR:-${PWD}}"
TRAIN_DIR="${YOUR_TRAIN_DIR}" # Location of training dataset
VAL_DIR="${YOUR_VAL_DIR}" # Location of validation dataset
# experiment output directory
EXP_DIR="${YOUR_EXP_DIR}"
HF_ACCESS_TOKEN="${YOUR_HF_TOKEN}"
HF_MODEL_NAME_OR_PATH="${YOUR_HF_MODEL_NAME_OR_PATH}"
# Add hf_model_name_or_path and turn off synthetic_data
HYDRA_FULL_ERROR=1 python3 ${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py \
recipes=fine-tuning/llama/hf_llama3_8b_seq8k_gpu_lora \
base_results_dir=${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results \
recipes.run.name="hf_llama3_lora" \
recipes.exp_manager.exp_dir="$EXP_DIR" \
recipes.model.data.train_dir="$TRAIN_DIR" \
recipes.model.data.val_dir="$VAL_DIR" \
recipes.model.hf_model_name_or_path="$HF_MODEL_NAME_OR_PATH" \
container="${IMAGE}" \
+cluster.container_mounts.0="/fsx:/fsx" \
recipes.model.hf_access_token="${HF_ACCESS_TOKEN}"
```
Setelah Anda mengonfigurasi semua parameter yang diperlukan dalam skrip sebelumnya, Anda dapat memulai pekerjaan pelatihan dengan menjalankannya.
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq8k_gpu_lora.sh
```
Untuk informasi selengkapnya tentang konfigurasi cluster Slurm, lihat. [Menjalankan pekerjaan pelatihan di HyperPod Slurm](cluster-specific-configurations-run-training-job-hyperpod-slurm.md)
# Tutorial pra-pelatihan klaster Kubernetes (GPU)
Ada dua cara untuk meluncurkan pekerjaan pelatihan di cluster GPU Kubernetes:
+ (Disarankan) [HyperPod alat baris perintah](https://github.com/aws/sagemaker-hyperpod-cli)
+ Peluncur NeMo gaya
**Prasyarat**
Sebelum Anda mulai mengatur lingkungan Anda, pastikan Anda memiliki:
Cluster HyperPod GPU Kubernetes diatur dengan benar.
Lokasi penyimpanan bersama. Ini bisa berupa sistem FSx file Amazon atau sistem NFS yang dapat diakses dari node cluster.
Data dalam salah satu format berikut:
JSON
JSONGZ (JSON Terkompresi)
PANAH
(Opsional) Anda harus mendapatkan HuggingFace token jika Anda menggunakan bobot model HuggingFace untuk pra-pelatihan atau fine-tuning. Untuk informasi selengkapnya tentang mendapatkan token, lihat [Token akses pengguna](https://huggingface.co/docs/hub/en/security-tokens).
## Pengaturan lingkungan GPU Kubernetes
Untuk menyiapkan lingkungan GPU Kubernetes, lakukan hal berikut:
+ Siapkan lingkungan virtual. Pastikan Anda menggunakan Python 3.9 atau lebih tinggi.
```
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
+ Instal dependensi menggunakan salah satu metode berikut:
+ (Disarankan): [HyperPod metode alat baris perintah](https://github.com/aws/sagemaker-hyperpod-cli):
```
# install HyperPod command line tools
git clone https://github.com/aws/sagemaker-hyperpod-cli
cd sagemaker-hyperpod-cli
pip3 install .
```
+ SageMaker HyperPod metode resep:
```
# install SageMaker HyperPod Recipes.
git clone --recursive git@github.com:aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
+ [Siapkan kubectl dan eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
+ [Instal Helm](https://helm.sh/docs/intro/install/)
+ Connect ke klaster Kubernetes
```
aws eks update-kubeconfig --region "CLUSTER_REGION" --name "CLUSTER_NAME"
hyperpod connect-cluster --cluster-name "CLUSTER_NAME" [--region "CLUSTER_REGION"] [--namespace ]
```
## Luncurkan pekerjaan pelatihan dengan SageMaker HyperPod CLI
Sebaiknya gunakan alat antarmuka SageMaker HyperPod baris perintah (CLI) untuk mengirimkan pekerjaan pelatihan Anda dengan konfigurasi Anda. Contoh berikut mengirimkan pekerjaan pelatihan untuk `hf_llama3_8b_seq16k_gpu_p5x16_pretrain` model.
+ `your_training_container`: Wadah Pembelajaran Mendalam. Untuk menemukan rilis terbaru dari wadah SMP, lihat[Catatan rilis untuk pustaka paralelisme SageMaker model](model-parallel-release-notes.md).
+ (Opsional) Anda dapat memberikan HuggingFace token jika Anda membutuhkan bobot yang telah dilatih sebelumnya HuggingFace dengan menetapkan pasangan nilai kunci berikut:
```
"recipes.model.hf_access_token": ""
```
```
hyperpod start-job --recipe training/llama/hf_llama3_8b_seq16k_gpu_p5x16_pretrain \
--persistent-volume-claims fsx-claim:data \
--override-parameters \
'{
"recipes.run.name": "hf-llama3-8b",
"recipes.exp_manager.exp_dir": "/data/",
"container": "658645717510.dkr.ecr..amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121",
"recipes.model.data.train_dir": "",
"recipes.model.data.val_dir": "",
"cluster": "k8s",
"cluster_type": "k8s"
}'
```
Setelah mengirimkan pekerjaan pelatihan, Anda dapat menggunakan perintah berikut untuk memverifikasi apakah Anda berhasil mengirimkannya.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
hf-llama3--worker-0 0/1 running 0 36s
```
Jika `STATUS` ada `PENDING` atau`ContainerCreating`, jalankan perintah berikut untuk mendapatkan detail lebih lanjut.
```
kubectl describe pod name_of_pod
```
Setelah pekerjaan `STATUS` berubah`Running`, Anda dapat memeriksa log dengan menggunakan perintah berikut.
```
kubectl logs name_of_pod
```
`STATUS`Menjadi `Completed` ketika Anda berlari`kubectl get pods`.
## Luncurkan pekerjaan pelatihan dengan peluncur resep
Atau, Anda dapat menggunakan SageMaker HyperPod resep untuk mengirimkan pekerjaan pelatihan Anda. Menggunakan resep melibatkan pembaruan`k8s.yaml`,`config.yaml`, dan menjalankan skrip peluncuran.
+ Di`k8s.yaml`, perbarui`persistent_volume_claims`. Ini memasang FSx klaim Amazon ke `/data` direktori setiap pod komputasi
```
persistent_volume_claims:
- claimName: fsx-claim
mountPath: data
```
+ Di`config.yaml`, perbarui `repo_url_or_path` di bawah`git`.
```
git:
repo_url_or_path:
branch: null
commit: null
entry_script: null
token: null
```
+ Perbarui `launcher_scripts/llama/run_hf_llama3_8b_seq16k_gpu_p5x16_pretrain.sh`
+ `your_contrainer`: Wadah Pembelajaran Mendalam. Untuk menemukan rilis terbaru dari wadah SMP, lihat[Catatan rilis untuk pustaka paralelisme SageMaker model](model-parallel-release-notes.md).
+ (Opsional) Anda dapat memberikan HuggingFace token jika Anda membutuhkan bobot yang telah dilatih sebelumnya HuggingFace dengan menetapkan pasangan nilai kunci berikut:
```
recipes.model.hf_access_token=
```
```
#!/bin/bash
#Users should setup their cluster type in /recipes_collection/config.yaml
REGION=""
IMAGE="658645717510.dkr.ecr.${REGION}.amazonaws.com/smdistributed-modelparallel:2.4.1-gpu-py311-cu121"
SAGEMAKER_TRAINING_LAUNCHER_DIR=${SAGEMAKER_TRAINING_LAUNCHER_DIR:-"$(pwd)"}
EXP_DIR="" # Location to save experiment info including logging, checkpoints, ect
TRAIN_DIR="" # Location of training dataset
VAL_DIR="" # Location of talidation dataset
HYDRA_FULL_ERROR=1 python3 "${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py" \
recipes=training/llama/hf_llama3_8b_seq8k_gpu_p5x16_pretrain \
base_results_dir="${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results" \
recipes.run.name="hf-llama3" \
recipes.exp_manager.exp_dir="$EXP_DIR" \
cluster=k8s \
cluster_type=k8s \
container="${IMAGE}" \
recipes.model.data.train_dir=$TRAIN_DIR \
recipes.model.data.val_dir=$VAL_DIR
```
+ Luncurkan pekerjaan pelatihan
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq16k_gpu_p5x16_pretrain.sh
```
Setelah Anda mengirimkan pekerjaan pelatihan, Anda dapat menggunakan perintah berikut untuk memverifikasi apakah Anda berhasil mengirimkannya.
```
kubectl get pods
```
```
NAME READY STATUS RESTARTS AGE
hf-llama3--worker-0 0/1 running 0 36s
```
Jika `STATUS` ada `PENDING` atau`ContainerCreating`, jalankan perintah berikut untuk mendapatkan detail lebih lanjut.
```
kubectl describe pod
```
Setelah pekerjaan `STATUS` berubah`Running`, Anda dapat memeriksa log dengan menggunakan perintah berikut.
```
kubectl logs name_of_pod
```
`STATUS`Kehendak beralih ke `Completed` saat Anda berlari`kubectl get pods`.
Untuk informasi selengkapnya tentang konfigurasi kluster k8s, lihat. [Menjalankan pekerjaan pelatihan di HyperPod k8s](cluster-specific-configurations-run-training-job-hyperpod-k8s.md)
# Tutorial pra-pelatihan klaster Trainium Kubernetes
Anda dapat menggunakan salah satu metode berikut untuk memulai pekerjaan pelatihan di cluster Trainium Kubernetes.
+ (Disarankan) [HyperPod alat baris perintah](https://github.com/aws/sagemaker-hyperpod-cli)
+ Peluncur NeMo gaya
**Prasyarat**
Sebelum Anda mulai mengatur lingkungan Anda, pastikan Anda memiliki:
Siapkan cluster HyperPod Trainium Kubernetes
Lokasi penyimpanan bersama yang dapat berupa sistem FSx file Amazon atau sistem NFS yang dapat diakses dari node cluster.
Data dalam salah satu format berikut:
JSON
JSONGZ (JSON Terkompresi)
PANAH
(Opsional) Anda harus mendapatkan HuggingFace token jika Anda menggunakan bobot model HuggingFace untuk pra-pelatihan atau fine-tuning. Untuk informasi selengkapnya tentang mendapatkan token, lihat [Token akses pengguna](https://huggingface.co/docs/hub/en/security-tokens).
## Siapkan lingkungan Trainium Kubernetes Anda
Untuk mengatur lingkungan Trainium Kubernetes, lakukan hal berikut:
1. **Selesaikan langkah-langkah dalam tutorial berikut: [HuggingFace Llama3-8B Pretraining](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/libraries/nxd-training/tutorials/hf_llama3_8B_pretraining.html#download-the-dataset) mulai dari Download dataset.**
1. Siapkan konfigurasi model. Mereka tersedia di repo Neuron. Untuk tutorial ini, Anda dapat menggunakan konfigurasi model llama3 8b.
1. Pengaturan lingkungan virtual. Pastikan Anda menggunakan Python 3.9 atau lebih tinggi.
```
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
1. Instal dependensi
+ (Disarankan) Gunakan alat baris HyperPod perintah berikut
```
# install HyperPod command line tools
git clone https://github.com/aws/sagemaker-hyperpod-cli
cd sagemaker-hyperpod-cli
pip3 install .
```
+ Jika Anda menggunakan SageMaker HyperPod resep, tentukan yang berikut ini
```
# install SageMaker HyperPod Recipes.
git clone --recursive git@github.com:aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
1. [Siapkan kubectl dan eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
1. [Instal Helm](https://helm.sh/docs/intro/install/)
1. Connect ke klaster Kubernetes
```
aws eks update-kubeconfig --region "${CLUSTER_REGION}" --name "${CLUSTER_NAME}"
hyperpod connect-cluster --cluster-name "${CLUSTER_NAME}" [--region "${CLUSTER_REGION}"] [--namespace ]
```
1. Wadah: [Wadah Neuron](https://github.com/aws-neuron/deep-learning-containers?tab=readme-ov-file#pytorch-training-neuronx)
## Luncurkan pekerjaan pelatihan dengan SageMaker HyperPod CLI
Sebaiknya gunakan alat antarmuka SageMaker HyperPod baris perintah (CLI) untuk mengirimkan pekerjaan pelatihan Anda dengan konfigurasi Anda. Contoh berikut mengirimkan pekerjaan pelatihan untuk model `hf_llama3_8b_seq8k_trn1x4_pretrain` Trainium.
+ `your_neuron_container`: [Wadah Neuron](https://github.com/aws-neuron/deep-learning-containers?tab=readme-ov-file#pytorch-training-neuronx).
+ `your_model_config`: Konfigurasi model dari bagian pengaturan lingkungan
+ (Opsional) Anda dapat memberikan HuggingFace token jika Anda membutuhkan bobot yang telah dilatih sebelumnya HuggingFace dengan menetapkan pasangan nilai kunci berikut:
```
"recipes.model.hf_access_token": ""
```
```
hyperpod start-job --recipe training/llama/hf_llama3_8b_seq8k_trn1x4_pretrain \
--persistent-volume-claims fsx-claim:data \
--override-parameters \
'{
"cluster": "k8s",
"cluster_type": "k8s",
"container": "",
"recipes.run.name": "hf-llama3",
"recipes.run.compile": 0,
"recipes.model.model_config": "",
"instance_type": "trn1.32xlarge",
"recipes.data.train_dir": ""
}'
```
Setelah mengirimkan pekerjaan pelatihan, Anda dapat menggunakan perintah berikut untuk memverifikasi apakah Anda berhasil mengirimkannya.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
hf-llama3--worker-0 0/1 running 0 36s
```
Jika `STATUS` ada `PENDING` atau`ContainerCreating`, jalankan perintah berikut untuk mendapatkan detail lebih lanjut.
```
kubectl describe pod name_of_pod
```
Setelah pekerjaan `STATUS` berubah`Running`, Anda dapat memeriksa log dengan menggunakan perintah berikut.
```
kubectl logs name_of_pod
```
`STATUS`Kehendak beralih ke `Completed` saat Anda berlari`kubectl get pods`.
## Luncurkan pekerjaan pelatihan dengan peluncur resep
Atau, gunakan SageMaker HyperPod resep untuk mengirimkan pekerjaan pelatihan Anda. Untuk mengirimkan pekerjaan pelatihan menggunakan resep, perbarui `k8s.yaml` dan`config.yaml`. Jalankan skrip bash untuk model untuk meluncurkannya.
+ Di`k8s.yaml`, perbarui persistent\$1volume\$1claims untuk memasang klaim FSx Amazon ke direktori /data di node komputasi
```
persistent_volume_claims:
- claimName: fsx-claim
mountPath: data
```
+ Perbarui peluncur\$1 \$1hf\$1llama3\$18b\$1seq8k\$1trn1x4\$1pretrain.sh scripts/llama/run
+ `your_neuron_contrainer`: Wadah dari bagian pengaturan lingkungan
+ `your_model_config`: Konfigurasi model dari bagian pengaturan lingkungan
(Opsional) Anda dapat memberikan HuggingFace token jika Anda membutuhkan bobot yang telah dilatih sebelumnya HuggingFace dengan menetapkan pasangan nilai kunci berikut:
```
recipes.model.hf_access_token=
```
```
#!/bin/bash
#Users should set up their cluster type in /recipes_collection/config.yaml
IMAGE=""
MODEL_CONFIG=""
SAGEMAKER_TRAINING_LAUNCHER_DIR=${SAGEMAKER_TRAINING_LAUNCHER_DIR:-"$(pwd)"}
TRAIN_DIR="" # Location of training dataset
VAL_DIR="" # Location of talidation dataset
HYDRA_FULL_ERROR=1 python3 "${SAGEMAKER_TRAINING_LAUNCHER_DIR}/main.py" \
recipes=training/llama/hf_llama3_8b_seq8k_trn1x4_pretrain \
base_results_dir="${SAGEMAKER_TRAINING_LAUNCHER_DIR}/results" \
recipes.run.name="hf-llama3-8b" \
instance_type=trn1.32xlarge \
recipes.model.model_config="$MODEL_CONFIG" \
cluster=k8s \
cluster_type=k8s \
container="${IMAGE}" \
recipes.data.train_dir=$TRAIN_DIR \
recipes.data.val_dir=$VAL_DIR
```
+ Luncurkan pekerjaan
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq8k_trn1x4_pretrain.sh
```
Setelah mengirimkan pekerjaan pelatihan, Anda dapat menggunakan perintah berikut untuk memverifikasi apakah Anda berhasil mengirimkannya.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
hf-llama3--worker-0 0/1 running 0 36s
```
Jika `STATUS` berada di `PENDING` atau`ContainerCreating`, jalankan perintah berikut untuk mendapatkan detail lebih lanjut.
```
kubectl describe pod name_of_pod
```
Setelah status pekerjaan berubah menjadi Running, Anda dapat memeriksa log dengan menggunakan perintah berikut.
```
kubectl logs name_of_pod
```
`STATUS`Kehendak beralih ke `Completed` saat Anda berlari`kubectl get pods`.
Untuk informasi selengkapnya tentang konfigurasi kluster k8s, lihat. [Tutorial pra-pelatihan klaster Trainium Kubernetes](#sagemaker-hyperpod-trainium-kubernetes-cluster-pretrain-tutorial)
# SageMaker pelatihan pekerjaan pra-pelatihan tutorial (GPU)
Tutorial ini memandu Anda melalui proses menyiapkan dan menjalankan pekerjaan pra-pelatihan menggunakan pekerjaan SageMaker pelatihan dengan instance GPU.
+ Siapkan lingkungan Anda
+ Luncurkan pekerjaan pelatihan menggunakan SageMaker HyperPod resep
Sebelum Anda mulai, pastikan Anda memiliki prasyarat berikut.
**Prasyarat**
Sebelum Anda mulai mengatur lingkungan Anda, pastikan Anda memiliki:
Sistem FSx file Amazon atau bucket Amazon S3 tempat Anda dapat memuat data dan mengeluarkan artefak pelatihan.
Meminta Kuota Layanan untuk 1x ml.p4d.24xlarge dan 1x ml.p5.48xlarge di Amazon AI. SageMaker Untuk meminta peningkatan kuota layanan, lakukan hal berikut:
Di konsol AWS Service Quotas, navigasikan ke AWS layanan,
Pilih **Amazon SageMaker AI**.
Pilih satu ml.p4d.24xlarge dan satu ml.p5.48xlarge instance.
Buat peran AWS Identity and Access Management(IAM) dengan kebijakan terkelola berikut untuk memberikan izin SageMaker AI untuk menjalankan contoh.
AmazonSageMakerFullAccess
Amazon EC2 FullAccess
Data dalam salah satu format berikut:
JSON
JSONGZ (JSON Terkompresi)
PANAH
(Opsional) Anda harus mendapatkan HuggingFace token jika Anda menggunakan bobot model HuggingFace untuk pra-pelatihan atau fine-tuning. Untuk informasi selengkapnya tentang mendapatkan token, lihat [Token akses pengguna](https://huggingface.co/docs/hub/en/security-tokens).
## Pengaturan lingkungan pekerjaan SageMaker pelatihan GPU
Sebelum Anda menjalankan pekerjaan SageMaker pelatihan, konfigurasikan AWS kredensyal dan wilayah pilihan Anda dengan menjalankan perintah. `aws configure` Sebagai alternatif dari perintah configure, Anda dapat memberikan kredensil Anda melalui variabel lingkungan seperti`AWS_ACCESS_KEY_ID`,, dan `AWS_SESSION_TOKEN.` Untuk informasi selengkapnya`AWS_SECRET_ACCESS_KEY`, lihat AI [SageMaker Python](https://github.com/aws/sagemaker-python-sdk) SDK.
Kami sangat menyarankan menggunakan notebook SageMaker AI Jupyter di SageMaker AI JupyterLab untuk meluncurkan pekerjaan SageMaker pelatihan. Untuk informasi selengkapnya, lihat [SageMaker JupyterLab](studio-updated-jl.md).
+ (Opsional) Siapkan lingkungan virtual dan dependensi. Jika Anda menggunakan notebook Jupyter di Amazon SageMaker Studio, Anda dapat melewati langkah ini. Pastikan Anda menggunakan Python 3.9 atau lebih tinggi.
```
# set up a virtual environment
python3 -m venv ${PWD}/venv
source venv/bin/activate
# install dependencies after git clone.
git clone --recursive git@github.com:aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
# Set the aws region.
aws configure set
```
+ Instal SageMaker AI Python SDK
```
pip3 install --upgrade sagemaker
```
+ `Container`: Wadah GPU diatur secara otomatis oleh SageMaker AI Python SDK. Anda juga dapat menyediakan wadah Anda sendiri.
**catatan**
Jika Anda menjalankan pekerjaan pelatihan multi-modal Llama 3.2, `transformers` versinya harus `4.45.2 ` atau lebih besar.
Tambahkan `source_dir` hanya saat Anda menggunakan SageMaker AI Python SDK`transformers==4.45.2`. `requirements.txt` Misalnya, tambahkan jika Anda menggunakannya di notebook di SageMaker AI JupyterLab.
Jika Anda menggunakan HyperPod resep untuk meluncurkan menggunakan tipe cluster`sm_jobs`, ini akan dilakukan secara otomatis.
## Luncurkan pekerjaan pelatihan menggunakan Notebook Jupyter
Anda dapat menggunakan kode Python berikut untuk menjalankan pekerjaan SageMaker pelatihan dengan resep Anda. Ini memanfaatkan PyTorch estimator dari AI [SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/) untuk mengirimkan resep. Contoh berikut meluncurkan resep llama3-8b pada platform Pelatihan AI. SageMaker
```
import os
import sagemaker,boto3
from sagemaker.debugger import TensorBoardOutputConfig
from sagemaker.pytorch import PyTorch
sagemaker_session = sagemaker.Session()
role = sagemaker.get_execution_role()
bucket = sagemaker_session.default_bucket()
output = os.path.join(f"s3://{bucket}", "output")
output_path = ""
overrides = {
"run": {
"results_dir": "/opt/ml/model",
},
"exp_manager": {
"exp_dir": "",
"explicit_log_dir": "/opt/ml/output/tensorboard",
"checkpoint_dir": "/opt/ml/checkpoints",
},
"model": {
"data": {
"train_dir": "/opt/ml/input/data/train",
"val_dir": "/opt/ml/input/data/val",
},
},
}
tensorboard_output_config = TensorBoardOutputConfig(
s3_output_path=os.path.join(output, 'tensorboard'),
container_local_output_path=overrides["exp_manager"]["explicit_log_dir"]
)
estimator = PyTorch(
output_path=output_path,
base_job_name=f"llama-recipe",
role=role,
instance_type="ml.p5.48xlarge",
training_recipe="training/llama/hf_llama3_8b_seq8k_gpu_p5x16_pretrain",
recipe_overrides=recipe_overrides,
sagemaker_session=sagemaker_session,
tensorboard_output_config=tensorboard_output_config,
)
estimator.fit(inputs={"train": "s3 or fsx input", "val": "s3 or fsx input"}, wait=True)
```
Kode sebelumnya membuat objek PyTorch estimator dengan resep pelatihan dan kemudian cocok dengan model menggunakan metode. `fit()` Gunakan parameter training\$1recipe untuk menentukan resep yang ingin Anda gunakan untuk pelatihan.
**catatan**
Jika Anda menjalankan pekerjaan pelatihan multi-modal Llama 3.2, versi transformer harus 4.45.2 atau lebih tinggi.
Tambahkan `source_dir` hanya saat Anda menggunakan SageMaker AI Python SDK `transformers==4.45.2` secara langsung. `requirements.txt` Misalnya, Anda harus menambahkan versi ke file teks saat Anda menggunakan buku catatan Jupyter.
Saat menerapkan titik akhir untuk pekerjaan SageMaker pelatihan, Anda harus menentukan URI gambar yang Anda gunakan. Jika tidak menyediakan URI gambar, estimator menggunakan image pelatihan sebagai image untuk penerapan. Gambar pelatihan yang SageMaker HyperPod menyediakan tidak berisi dependensi yang diperlukan untuk inferensi dan penerapan. Berikut ini adalah contoh bagaimana gambar inferensi dapat digunakan untuk penerapan:
```
from sagemaker import image_uris
container=image_uris.retrieve(framework='pytorch',region='us-west-2',version='2.0',py_version='py310',image_scope='inference', instance_type='ml.p4d.24xlarge')
predictor = estimator.deploy(initial_instance_count=1,instance_type='ml.p4d.24xlarge',image_uri=container)
```
**catatan**
Menjalankan kode sebelumnya pada instance notebook Sagemaker mungkin membutuhkan lebih dari penyimpanan 5GB default yang disediakan AI. SageMaker JupyterLab Jika Anda mengalami masalah ruang yang tidak tersedia, buat instance notebook baru di mana Anda menggunakan instance notebook yang berbeda dan tingkatkan penyimpanan notebook.
## Luncurkan pekerjaan pelatihan dengan peluncur resep
Perbarui `./recipes_collection/cluster/sm_jobs.yaml` file agar terlihat seperti berikut:
```
sm_jobs_config:
output_path:
tensorboard_config:
output_path:
container_logs_path: /opt/ml/output/tensorboard # Path to logs on the container
wait: True # Whether to wait for training job to finish
inputs: # Inputs to call fit with. Set either s3 or file_system, not both.
s3: # Dictionary of channel names and s3 URIs. For GPUs, use channels for train and validation.
train:
val: null
additional_estimator_kwargs: # All other additional args to pass to estimator. Must be int, float or string.
max_run: 180000
enable_remote_debug: True
recipe_overrides:
exp_manager:
explicit_log_dir: /opt/ml/output/tensorboard
data:
train_dir: /opt/ml/input/data/train
model:
model_config: /opt/ml/input/data/train/config.json
compiler_cache_url: ""
```
Perbarui `./recipes_collection/config.yaml` untuk menentukan `sm_jobs` di `cluster` dan`cluster_type`.
```
defaults:
- _self_
- cluster: sm_jobs # set to `slurm`, `k8s` or `sm_jobs`, depending on the desired cluster
- recipes: training/llama/hf_llama3_8b_seq8k_trn1x4_pretrain
cluster_type: sm_jobs # bcm, bcp, k8s or sm_jobs. If bcm, k8s or sm_jobs, it must match - cluster above.
```
Luncurkan pekerjaan dengan perintah berikut
```
python3 main.py --config-path recipes_collection --config-name config
```
Untuk informasi selengkapnya tentang mengonfigurasi pekerjaan SageMaker pelatihan, lihat Menjalankan pekerjaan pelatihan tentang pekerjaan SageMaker pelatihan.
# Tutorial SageMaker pra-pelatihan pekerjaan pelatihan trainium
Tutorial ini memandu Anda melalui proses menyiapkan dan menjalankan pekerjaan pra-pelatihan menggunakan pekerjaan pelatihan dengan SageMaker instance AWS Trainium.
+ Siapkan lingkungan Anda
+ Luncurkan pekerjaan pelatihan
Sebelum Anda mulai, pastikan Anda memiliki prasyarat berikut.
**Prasyarat**
Sebelum Anda mulai mengatur lingkungan Anda, pastikan Anda memiliki:
Sistem FSx file Amazon atau bucket S3 tempat Anda dapat memuat data dan mengeluarkan artefak pelatihan.
Minta Kuota Layanan untuk `ml.trn1.32xlarge` instans di Amazon SageMaker AI. Untuk meminta peningkatan kuota layanan, lakukan hal berikut:
Arahkan ke konsol AWS Service Quotas.
Pilih AWS layanan.
Pilih JupyterLab.
Tentukan satu contoh untuk`ml.trn1.32xlarge`.
Buat peran AWS Identity and Access Management (IAM) dengan kebijakan yang `AmazonEC2FullAccess` dikelola `AmazonSageMakerFullAccess` dan dikelola. Kebijakan ini memberi Amazon SageMaker AI izin untuk menjalankan contoh.
Data dalam salah satu format berikut:
JSON
JSONGZ (JSON Terkompresi)
PANAH
(Opsional) Jika Anda memerlukan bobot yang telah dilatih sebelumnya dari HuggingFace atau jika Anda melatih model Llama 3.2, Anda harus mendapatkan HuggingFace token sebelum memulai pelatihan. Untuk informasi selengkapnya tentang mendapatkan token, lihat [Token akses pengguna](https://huggingface.co/docs/hub/en/security-tokens).
## Siapkan lingkungan Anda untuk pekerjaan pelatihan Trainium SageMaker
Sebelum Anda menjalankan pekerjaan SageMaker pelatihan, gunakan `aws configure` perintah untuk mengonfigurasi AWS kredensyal dan wilayah pilihan Anda. Sebagai alternatif, Anda juga dapat memberikan kredensyal Anda melalui variabel lingkungan seperti`AWS_ACCESS_KEY_ID`,`AWS_SECRET_ACCESS_KEY`, dan. `AWS_SESSION_TOKEN` Untuk informasi selengkapnya, lihat [SageMaker AI Python SDK](https://github.com/aws/sagemaker-python-sdk).
Kami sangat menyarankan menggunakan notebook SageMaker AI Jupyter di SageMaker AI JupyterLab untuk meluncurkan pekerjaan SageMaker pelatihan. Untuk informasi selengkapnya, lihat [SageMaker JupyterLab](studio-updated-jl.md).
+ (Opsional) Jika Anda menggunakan notebook Jupyter di Amazon SageMaker Studio, Anda dapat melewatkan menjalankan perintah berikut. Pastikan untuk menggunakan versi >= python 3.9
```
# set up a virtual environment
python3 -m venv ${PWD}/venv
source venv/bin/activate
# install dependencies after git clone.
git clone --recursive git@github.com:aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
+ Instal SageMaker AI Python SDK
```
pip3 install --upgrade sagemaker
```
+
+ Jika Anda menjalankan pekerjaan pelatihan multi-modal llama 3.2, `transformers` versinya harus `4.45.2` atau lebih besar.
+ Tambahkan `transformers==4.45.2` ke `requirements.txt` source\$1dir hanya saat Anda menggunakan AI SageMaker Python SDK.
+ Jika Anda menggunakan HyperPod resep untuk diluncurkan menggunakan `sm_jobs` sebagai tipe cluster, Anda tidak perlu menentukan versi transformer.
+ `Container`: Wadah Neuron diatur secara otomatis oleh SageMaker AI Python SDK.
## Luncurkan pekerjaan pelatihan dengan Notebook Jupyter
Anda dapat menggunakan kode Python berikut untuk menjalankan pekerjaan SageMaker pelatihan menggunakan resep Anda. Ini memanfaatkan PyTorch estimator dari AI [SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/) untuk mengirimkan resep. Contoh berikut meluncurkan resep llama3-8b sebagai AI Training Job. SageMaker
+ `compiler_cache_url`: Cache yang akan digunakan untuk menyimpan artefak yang dikompilasi, seperti artefak Amazon S3.
```
import os
import sagemaker,boto3
from sagemaker.debugger import TensorBoardOutputConfig
from sagemaker.pytorch import PyTorch
sagemaker_session = sagemaker.Session()
role = sagemaker.get_execution_role()
recipe_overrides = {
"run": {
"results_dir": "/opt/ml/model",
},
"exp_manager": {
"explicit_log_dir": "/opt/ml/output/tensorboard",
},
"data": {
"train_dir": "/opt/ml/input/data/train",
},
"model": {
"model_config": "/opt/ml/input/data/train/config.json",
},
"compiler_cache_url": ""
}
tensorboard_output_config = TensorBoardOutputConfig(
s3_output_path=os.path.join(output, 'tensorboard'),
container_local_output_path=overrides["exp_manager"]["explicit_log_dir"]
)
estimator = PyTorch(
output_path=output_path,
base_job_name=f"llama-trn",
role=role,
instance_type="ml.trn1.32xlarge",
sagemaker_session=sagemaker_session,
training_recipe="training/llama/hf_llama3_70b_seq8k_trn1x16_pretrain",
recipe_overrides=recipe_overrides,
)
estimator.fit(inputs={"train": "your-inputs"}, wait=True)
```
Kode sebelumnya membuat objek PyTorch estimator dengan resep pelatihan dan kemudian cocok dengan model menggunakan metode. `fit()` Gunakan `training_recipe` parameter untuk menentukan resep yang ingin Anda gunakan untuk pelatihan.
## Luncurkan pekerjaan pelatihan dengan peluncur resep
+ Perbarui `./recipes_collection/cluster/sm_jobs.yaml`
+ compiler\$1cache\$1url: URL yang digunakan untuk menyimpan artefak. Ini bisa berupa URL Amazon S3.
```
sm_jobs_config:
output_path:
wait: True
tensorboard_config:
output_path:
container_logs_path: /opt/ml/output/tensorboard # Path to logs on the container
wait: True # Whether to wait for training job to finish
inputs: # Inputs to call fit with. Set either s3 or file_system, not both.
s3: # Dictionary of channel names and s3 URIs. For GPUs, use channels for train and validation.
train:
val: null
additional_estimator_kwargs: # All other additional args to pass to estimator. Must be int, float or string.
max_run: 180000
image_uri:
enable_remote_debug: True
py_version: py39
recipe_overrides:
model:
exp_manager:
exp_dir:
data:
train_dir: /opt/ml/input/data/train
val_dir: /opt/ml/input/data/val
```
+ Perbarui `./recipes_collection/config.yaml`
```
defaults:
- _self_
- cluster: sm_jobs
- recipes: training/llama/hf_llama3_8b_seq8k_trn1x4_pretrain
cluster_type: sm_jobs # bcm, bcp, k8s or sm_jobs. If bcm, k8s or sm_jobs, it must match - cluster above.
instance_type: ml.trn1.32xlarge
base_results_dir: ~/sm_job/hf_llama3_8B # Location to store the results, checkpoints and logs.
```
+ Luncurkan pekerjaan dengan `main.py`
```
python3 main.py --config-path recipes_collection --config-name config
```
Untuk informasi selengkapnya tentang mengonfigurasi pekerjaan SageMaker pelatihan, lihat[SageMaker pelatihan pekerjaan pra-pelatihan tutorial (GPU)](sagemaker-hyperpod-gpu-sagemaker-training-jobs-pretrain-tutorial.md).
# Konfigurasi default
Bagian ini menguraikan komponen dan pengaturan penting yang diperlukan untuk memulai dan menyesuaikan proses pelatihan Model Bahasa Besar (LLM) Anda menggunakan. SageMaker HyperPod Bagian ini mencakup repositori kunci, file konfigurasi, dan struktur resep yang membentuk dasar pekerjaan pelatihan Anda. Memahami konfigurasi default ini sangat penting untuk menyiapkan dan mengelola alur kerja pelatihan LLM Anda secara efektif, baik Anda menggunakan resep yang telah ditentukan sebelumnya atau menyesuaikannya agar sesuai dengan kebutuhan spesifik Anda.
**Topics**
+ [GitHub repositori](github-repositories.md)
+ [Konfigurasi umum](sagemaker-hyperpod-recipes-general-configuration.md)
# GitHub repositori
Untuk memulai pekerjaan pelatihan, Anda menggunakan file dari dua GitHub repositori yang berbeda:
+ [SageMaker HyperPod resep](https://github.com/aws/sagemaker-hyperpod-recipes)
+ [SageMaker HyperPod adaptor pelatihan untuk NeMo](https://github.com/aws/sagemaker-hyperpod-training-adapter-for-nemo)
Repositori ini berisi komponen penting untuk memulai, mengelola, dan menyesuaikan proses pelatihan Large Language Model (LLM). Anda menggunakan skrip dari repositori untuk mengatur dan menjalankan pekerjaan pelatihan untuk Anda. LLMs
## HyperPod repositori resep
Gunakan repositori [SageMaker HyperPod resep](https://github.com/aws/sagemaker-hyperpod-recipes) untuk mendapatkan resep.
1. `main.py`: File ini berfungsi sebagai titik masuk utama untuk memulai proses pengiriman pekerjaan pelatihan ke cluster atau pekerjaan pelatihan. SageMaker
1. `launcher_scripts`: Direktori ini berisi kumpulan skrip yang umum digunakan yang dirancang untuk memfasilitasi proses pelatihan untuk berbagai Model Bahasa Besar (LLMs).
1. `recipes_collection`: Folder ini menampung kompilasi resep LLM yang telah ditentukan sebelumnya yang disediakan oleh pengembang. Pengguna dapat memanfaatkan resep ini bersama dengan data khusus mereka untuk melatih model LLM yang disesuaikan dengan kebutuhan spesifik mereka.
Anda menggunakan SageMaker HyperPod resep untuk meluncurkan pelatihan atau pekerjaan fine-tuning. Terlepas dari cluster yang Anda gunakan, proses pengiriman pekerjaan adalah sama. Misalnya, Anda dapat menggunakan skrip yang sama untuk mengirimkan pekerjaan ke klaster Slurm atau Kubernetes. Peluncur mengirimkan pekerjaan pelatihan berdasarkan tiga file konfigurasi:
1. Konfigurasi Umum (`config.yaml`): Termasuk pengaturan umum seperti parameter default atau variabel lingkungan yang digunakan dalam pekerjaan pelatihan.
1. Konfigurasi Cluster (cluster): Untuk pekerjaan pelatihan menggunakan cluster saja. Jika Anda mengirimkan tugas pelatihan ke klaster Kubernetes, Anda mungkin perlu menentukan informasi seperti volume, label, atau kebijakan restart. Untuk cluster Slurm, Anda mungkin perlu menentukan nama pekerjaan Slurm. Semua parameter terkait dengan cluster tertentu yang Anda gunakan.
1. Resep (resep): Resep berisi pengaturan untuk pekerjaan pelatihan Anda, seperti jenis model, derajat sharding, atau jalur dataset. Misalnya, Anda dapat menentukan Llama sebagai model pelatihan Anda dan melatihnya menggunakan teknik paralelisme model atau data seperti Fully Sharded Distributed Parallel (FSDP) di delapan mesin. Anda juga dapat menentukan frekuensi atau jalur pos pemeriksaan yang berbeda untuk pekerjaan pelatihan Anda.
Setelah Anda menentukan resep, Anda menjalankan skrip peluncur untuk menentukan pekerjaan end-to-end pelatihan pada cluster berdasarkan konfigurasi melalui `main.py` titik masuk. Untuk setiap resep yang Anda gunakan, ada skrip shell yang menyertainya yang terletak di folder launch\$1scripts. Contoh-contoh ini memandu Anda melalui pengiriman dan memulai pekerjaan pelatihan. Gambar berikut mengilustrasikan bagaimana peluncur SageMaker HyperPod resep mengirimkan pekerjaan pelatihan ke cluster berdasarkan sebelumnya. Saat ini, peluncur SageMaker HyperPod resep dibangun di atas Nvidia NeMo Framework Launcher. Untuk informasi selengkapnya, lihat [Panduan NeMo Peluncur](https://docs.nvidia.com/nemo-framework/user-guide/latest/overview.html).
![\[Diagram yang menggambarkan alur kerja peluncur HyperPod resep. Di sebelah kiri, di dalam kotak putus-putus, ada tiga ikon file berlabel “Resep”, “config.yaml”, dan “slurm.yaml atau k8s.yaml atau sm_job.yaml (Konfigurasi cluster)”. Panah menunjuk dari kotak ini ke kotak tengah berlabel "Peluncur HyperPod resep”. Dari kotak tengah ini, panah lain menunjuk ke kanan ke “Training Job”, dengan "main.py" tertulis di atas panah.\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/images/sagemaker-hyperpod-recipe-launcher.png)
## HyperPod repositori adaptor resep
Adaptor SageMaker HyperPod pelatihan adalah kerangka pelatihan. Anda dapat menggunakannya untuk mengelola seluruh siklus hidup pekerjaan pelatihan Anda. Gunakan adaptor untuk mendistribusikan pra-pelatihan atau fine-tuning model Anda di beberapa mesin. Adaptor menggunakan teknik paralelisme yang berbeda untuk mendistribusikan pelatihan. Ini juga menangani implementasi dan manajemen penyimpanan pos pemeriksaan. Untuk detail selengkapnya, lihat [Pengaturan lanjutan](cluster-specific-configurations-advanced-settings.md).
Gunakan [repositori adaptor SageMaker HyperPod resep](https://github.com/aws/sagemaker-hyperpod-training-adapter-for-nemo) untuk menggunakan adaptor resep.
1. `src`: Direktori ini berisi implementasi pelatihan Model Bahasa Skala Besar (LLM), yang mencakup berbagai fitur seperti paralelisme model, pelatihan presisi campuran, dan manajemen pos pemeriksaan.
1. `examples`: Folder ini menyediakan kumpulan contoh yang menunjukkan cara membuat titik masuk untuk melatih model LLM, berfungsi sebagai panduan praktis bagi pengguna.
# Konfigurasi umum
File config.yaml menentukan resep pelatihan dan cluster. Ini juga mencakup konfigurasi runtime seperti variabel lingkungan untuk pekerjaan pelatihan.
```
defaults:
- _self_
- cluster: slurm
- recipes: training/llama/hf_llama3_8b_seq8192_gpu
instance_type: p5.48xlarge
git:
repo_url_or_path: null
branch: null
commit: null
entry_script: null
token: null
env_vars:
NCCL_DEBUG: WARN
```
Anda dapat memodifikasi parameter berikut di`config.yaml`:
1. `defaults`: Tentukan pengaturan default Anda, seperti cluster default atau resep default.
1. `instance_type`: Ubah jenis instans Amazon EC2 agar sesuai dengan jenis instans yang Anda gunakan.
1. `git`: Tentukan lokasi repositori adaptor SageMaker HyperPod resep untuk pekerjaan pelatihan.
1. `env_vars`: Anda dapat menentukan variabel lingkungan yang akan diteruskan ke pekerjaan pelatihan runtime Anda. Misalnya, Anda dapat menyesuaikan tingkat logging NCCL dengan menentukan variabel lingkungan NCCL\$1DEBUG.
Resepnya adalah konfigurasi inti yang mendefinisikan arsitektur pekerjaan pelatihan Anda. File ini mencakup banyak informasi penting untuk pekerjaan pelatihan Anda, seperti berikut ini:
+ Apakah akan menggunakan paralelisme model
+ Sumber dataset Anda
+ Pelatihan presisi campuran
+ Konfigurasi terkait pos pemeriksaan
Anda dapat menggunakan resep apa adanya. Anda juga dapat menggunakan informasi berikut untuk memodifikasinya.
## run
Berikut ini adalah informasi lari dasar untuk menjalankan pekerjaan pelatihan Anda.
```
run:
name: llama-8b
results_dir: ${base_results_dir}/${.name}
time_limit: "6-00:00:00"
model_type: hf
```
1. `name`: Tentukan nama untuk pekerjaan pelatihan Anda di file konfigurasi.
1. `results_dir`: Anda dapat menentukan direktori tempat hasil pekerjaan pelatihan Anda disimpan.
1. `time_limit`: Anda dapat mengatur waktu pelatihan maksimum untuk pekerjaan pelatihan Anda untuk mencegahnya menempati sumber daya perangkat keras terlalu lama.
1. `model_type`: Anda dapat menentukan jenis model yang Anda gunakan. Misalnya, Anda dapat menentukan `hf` apakah model Anda berasal dari HuggingFace.
## manajer exp\$1
Exp\$1manager mengonfigurasi eksperimen. Dengan exp\$1manager, Anda dapat menentukan bidang seperti direktori output atau pengaturan pos pemeriksaan. Berikut ini adalah contoh bagaimana Anda dapat mengkonfigurasi exp\$1manager.
```
exp_manager:
exp_dir: null
name: experiment
create_tensorboard_logger: True
```
1. `exp_dir`: Direktori eksperimen menyertakan output standar dan file kesalahan standar untuk pekerjaan pelatihan Anda. Secara default, ia menggunakan direktori Anda saat ini.
1. `name`: Nama eksperimen yang digunakan untuk mengidentifikasi eksperimen Anda di bawah exp\$1dir.
1. `create_tensorboard_logger`: Tentukan `True` atau `False` untuk mengaktifkan atau menonaktifkan TensorBoard logger.
## Checkpointing
Berikut adalah tiga jenis checkpointing yang kami dukung:
+ Pos pemeriksaan otomatis
+ Pos pemeriksaan manual
+ Checkpointing penuh
### Pos pemeriksaan otomatis
Jika Anda menyimpan atau memuat pos pemeriksaan yang dikelola secara otomatis oleh adaptor SageMaker HyperPod resep, Anda dapat mengaktifkan`auto_checkpoint`. Untuk mengaktifkan`auto_checkpoint`, atur `enabled` ke`True`. Anda dapat menggunakan pos pemeriksaan otomatis untuk pelatihan dan fine-tuning. Anda dapat menggunakan pos pemeriksaan otomatis untuk sistem file bersama dan Amazon S3.
```
exp_manager
checkpoint_dir: ${recipes.exp_manager.exp_dir}/checkpoints/
auto_checkpoint:
enabled: True
```
Pos pemeriksaan otomatis menyimpan local\$1state\$1dict secara asinkron dengan interval penyimpanan optimal yang dihitung secara otomatis.
**catatan**
Di bawah mode checkpointing ini, checkpointing yang disimpan secara otomatis tidak mendukung re-sharding di antara latihan berjalan. Untuk melanjutkan dari pos pemeriksaan tersimpan otomatis terbaru, Anda harus mempertahankan derajat pecahan yang sama. Anda tidak perlu menentukan informasi tambahan untuk melanjutkan secara otomatis.
### Pos pemeriksaan manual
Anda dapat memodifikasi `checkpoint_callback_params` untuk menyimpan pos pemeriksaan perantara secara asinkron di shared\$1state\$1dict. Misalnya, Anda dapat menentukan konfigurasi berikut untuk mengaktifkan pos pemeriksaan sharded setiap 10 langkah dan menyimpan 3 pos pemeriksaan terbaru.
Checkpointing sharded memungkinkan Anda mengubah derajat pecahan antara latihan berjalan dan memuat pos pemeriksaan dengan pengaturan. `resume_from_checkpoint`
**catatan**
Jika merupakan fine tuning PEFT, checkpointing sharded tidak mendukung Amazon S3.
Checkpointing otomatis dan manual saling eksklusif.
Hanya derajat pecahan FSDP dan perubahan derajat replikasi yang diizinkan.
```
exp_manager:
checkpoint_callback_params:
# Set save_top_k = 0 to disable sharded checkpointing
save_top_k: 3
every_n_train_steps: 10
monitor: "step"
mode: "max"
save_last: False
resume_from_checkpoint: ${recipes.exp_manager.exp_dir}/checkpoints/
```
Untuk mempelajari selengkapnya tentang pos pemeriksaan, lihat. [Checkpointing menggunakan SMP](model-parallel-core-features-v2-checkpoints.md)
### Checkpointing penuh
Pos pemeriksaan full\$1state\$1dict yang diekspor dapat digunakan untuk inferensi atau fine tuning. Anda dapat memuat pos pemeriksaan lengkap melalui hf\$1model\$1name\$1or\$1path. Di bawah mode ini, hanya bobot model yang disimpan.
Untuk mengekspor model full\$1state\$1dict, Anda dapat mengatur parameter berikut.
**catatan**
Saat ini, pos pemeriksaan penuh tidak didukung untuk pos pemeriksaan Amazon S3. Anda tidak dapat mengatur jalur S3 `exp_manager.checkpoint_dir` jika Anda mengaktifkan pos pemeriksaan penuh. Namun, Anda dapat mengatur `exp_manager.export_full_model.final_export_dir` ke direktori tertentu di sistem file lokal Anda saat menyetel `exp_manager.checkpoint_dir` ke jalur Amazon S3.
```
exp_manager:
export_full_model:
# Set every_n_train_steps = 0 to disable full checkpointing
every_n_train_steps: 0
save_last: True
final_export_dir : null
```
## model
Tentukan berbagai aspek arsitektur model dan proses pelatihan Anda. Ini termasuk pengaturan untuk paralelisme model, presisi, dan penanganan data. Di bawah ini adalah komponen utama yang dapat Anda konfigurasikan dalam bagian model:
### model paralelisme
Setelah Anda menentukan resep, Anda menentukan model yang Anda latih. Anda juga dapat menentukan paralelisme model. Misalnya, Anda dapat mendefinisikan tensor\$1model\$1parallel\$1degree. Anda dapat mengaktifkan fitur lain seperti pelatihan dengan FP8 presisi. Misalnya, Anda dapat melatih model dengan paralelisme tensor dan paralelisme konteks:
```
model:
model_type: llama_v3
# Base configs
train_batch_size: 4
val_batch_size: 1
seed: 12345
grad_clip: 1.0
# Model parallelism
tensor_model_parallel_degree: 4
expert_model_parallel_degree: 1
context_parallel_degree: 2
```
Untuk mendapatkan pemahaman yang lebih baik tentang berbagai jenis teknik paralelisme model, Anda dapat merujuk pada pendekatan berikut:
1. [Paralelisme tensor](model-parallel-core-features-v2-tensor-parallelism.md)
1. [Paralelisme ahli](model-parallel-core-features-v2-expert-parallelism.md)
1. [Paralelisme konteks](model-parallel-core-features-v2-context-parallelism.md)
1. [Paralelisme data sharded hibrid](model-parallel-core-features-v2-sharded-data-parallelism.md)
### FP8
Untuk mengaktifkan FP8 (presisi floating-point 8-bit), Anda dapat menentukan konfigurasi FP8 -related dalam contoh berikut:
```
model:
# FP8 config
fp8: True
fp8_amax_history_len: 1024
fp8_amax_compute_algo: max
```
Penting untuk dicatat bahwa format FP8 data saat ini hanya didukung pada jenis instans P5. Jika Anda menggunakan jenis instans yang lebih lama, seperti P4, nonaktifkan FP8 fitur untuk proses pelatihan model Anda. Untuk informasi lebih lanjut tentang FP8, lihat[Pelatihan presisi campuran](model-parallel-core-features-v2-mixed-precision.md).
### data
Anda dapat menentukan kumpulan data khusus untuk pekerjaan pelatihan Anda dengan menambahkan jalur data di bawah data. Modul data dalam sistem kami mendukung format data berikut:
1. JSON
1. JSONGZ (JSON Terkompresi)
1. PANAH
Namun, Anda bertanggung jawab untuk menyiapkan dataset pra-token Anda sendiri. Jika Anda adalah pengguna tingkat lanjut dengan persyaratan khusus, ada juga opsi untuk mengimplementasikan dan mengintegrasikan modul data yang disesuaikan. [Untuk informasi selengkapnya tentang HuggingFace kumpulan data, lihat Datasets.](https://huggingface.co/docs/datasets/v3.1.0/en/index)
```
model:
data:
train_dir: /path/to/your/train/data
val_dir: /path/to/your/val/data
dataset_type: hf
use_synthetic_data: False
```
Anda dapat menentukan bagaimana Anda melatih model. Secara default, resep menggunakan pra-pelatihan alih-alih fine-tuning. Contoh berikut mengonfigurasi resep untuk menjalankan pekerjaan fine-tuning dengan LoRa (Adaptasi Peringkat Rendah).
```
model:
# Fine tuning config
do_finetune: True
# The path to resume from, needs to be HF compatible
hf_model_name_or_path: null
hf_access_token: null
# PEFT config
peft:
peft_type: lora
rank: 32
alpha: 16
dropout: 0.1
```
Untuk informasi tentang resep, lihat [SageMaker HyperPodresep](https://github.com/aws/sagemaker-hyperpod-recipes).
# Konfigurasi khusus cluster
SageMaker HyperPod menawarkan fleksibilitas dalam menjalankan pekerjaan pelatihan di berbagai lingkungan cluster. Setiap lingkungan memiliki persyaratan konfigurasi dan proses penyiapannya sendiri. Bagian ini menguraikan langkah-langkah dan konfigurasi yang diperlukan untuk menjalankan pekerjaan pelatihan di SageMaker HyperPod Slurm, SageMaker HyperPod k8s, dan pekerjaan pelatihan. SageMaker Memahami konfigurasi ini sangat penting untuk secara efektif memanfaatkan kekuatan pelatihan terdistribusi di lingkungan pilihan Anda.
Anda dapat menggunakan resep di lingkungan cluster berikut:
+ SageMaker HyperPod Orkestrasi Slurm
+ SageMaker HyperPod Orkestrasi Layanan Amazon Elastic Kubernetes
+ SageMaker Lowongan Training
Untuk meluncurkan pekerjaan pelatihan di cluster, atur dan instal konfigurasi dan lingkungan cluster yang sesuai.
**Topics**
+ [Menjalankan pekerjaan pelatihan di HyperPod Slurm](cluster-specific-configurations-run-training-job-hyperpod-slurm.md)
+ [Menjalankan pekerjaan pelatihan di HyperPod k8s](cluster-specific-configurations-run-training-job-hyperpod-k8s.md)
+ [Menjalankan pekerjaan SageMaker pelatihan](cluster-specific-configurations-run-sagemaker-training-job.md)
# Menjalankan pekerjaan pelatihan di HyperPod Slurm
SageMaker HyperPod Resep mendukung pengiriman pekerjaan pelatihan ke cluster GPU/Trainium slurm. Sebelum Anda mengirimkan pekerjaan pelatihan, perbarui konfigurasi cluster. Gunakan salah satu metode berikut untuk memperbarui konfigurasi cluster:
+ Memodifikasi `slurm.yaml`
+ Ganti melalui baris perintah
Setelah Anda memperbarui konfigurasi cluster, instal lingkungan.
## Konfigurasikan cluster
Untuk mengirimkan pekerjaan pelatihan ke cluster Slurm, tentukan konfigurasi khusus Slurm. Ubah `slurm.yaml` untuk mengkonfigurasi cluster Slurm. Berikut ini adalah contoh konfigurasi cluster Slurm. Anda dapat memodifikasi file ini untuk kebutuhan pelatihan Anda sendiri:
```
job_name_prefix: 'sagemaker-'
slurm_create_submission_file_only: False
stderr_to_stdout: True
srun_args:
# - "--no-container-mount-home"
slurm_docker_cfg:
docker_args:
# - "--runtime=nvidia"
post_launch_commands:
container_mounts:
- "/fsx:/fsx"
```
1. `job_name_prefix`: Tentukan awalan nama pekerjaan untuk dengan mudah mengidentifikasi kiriman Anda ke cluster Slurm.
1. `slurm_create_submission_file_only`: Setel konfigurasi ini ke True untuk dry run guna membantu Anda men-debug.
1. `stderr_to_stdout`: Tentukan apakah Anda mengarahkan kesalahan standar (stderr) ke output standar (stdout).
1. `srun_args`: Sesuaikan konfigurasi srun tambahan, seperti mengecualikan node komputasi tertentu. Untuk informasi selengkapnya, lihat dokumentasi srun.
1. `slurm_docker_cfg`: Peluncur SageMaker HyperPod resep meluncurkan wadah Docker untuk menjalankan pekerjaan pelatihan Anda. Anda dapat menentukan argumen Docker tambahan dalam parameter ini.
1. `container_mounts`: Tentukan volume yang Anda pasang ke wadah untuk peluncur resep, untuk pekerjaan pelatihan Anda untuk mengakses file dalam volume tersebut.
# Menjalankan pekerjaan pelatihan di HyperPod k8s
SageMaker HyperPod Recipes mendukung pengiriman pekerjaan pelatihan ke cluster GPU/Trainium Kubernetes. Sebelum Anda mengirimkan pekerjaan pelatihan, lakukan salah satu hal berikut:
+ Memodifikasi berkas konfigurasi `k8s.yaml` cluster
+ Ganti konfigurasi cluster melalui baris perintah
Setelah Anda melakukan salah satu langkah sebelumnya, instal lingkungan yang sesuai.
## Konfigurasikan cluster menggunakan `k8s.yaml`
Untuk mengirimkan tugas pelatihan ke klaster Kubernetes, Anda menentukan konfigurasi khusus Kubernetes. Konfigurasi termasuk namespace cluster atau lokasi volume persisten.
```
pullPolicy: Always
restartPolicy: Never
namespace: default
persistent_volume_claims:
- null
```
1. `pullPolicy`: Anda dapat menentukan kebijakan tarik saat mengirimkan pekerjaan pelatihan. Jika Anda menentukan “Selalu,” klaster Kubernetes akan selalu menarik gambar Anda dari repositori. Untuk informasi selengkapnya, lihat [Kebijakan tarik gambar](https://kubernetes.io/docs/concepts/containers/images/#image-pull-policy).
1. `restartPolicy`: Tentukan apakah akan memulai kembali pekerjaan pelatihan Anda jika gagal.
1. `namespace`: Anda dapat menentukan namespace Kubernetes tempat Anda mengirimkan tugas pelatihan.
1. `persistent_volume_claims`: Anda dapat menentukan volume bersama untuk pekerjaan pelatihan Anda untuk semua proses pelatihan untuk mengakses file dalam volume.
# Menjalankan pekerjaan SageMaker pelatihan
SageMaker HyperPod Resep mendukung pengiriman pekerjaan SageMaker pelatihan. Sebelum Anda mengirimkan pekerjaan pelatihan, Anda harus memperbarui konfigurasi cluster`sm_job.yaml`, dan menginstal lingkungan yang sesuai.
## Gunakan resep Anda sebagai pekerjaan SageMaker pelatihan
Anda dapat menggunakan resep Anda sebagai pekerjaan SageMaker pelatihan jika Anda tidak menjadi tuan rumah cluster. Anda harus memodifikasi file konfigurasi pekerjaan SageMaker pelatihan,`sm_job.yaml`, untuk menjalankan resep Anda.
```
sm_jobs_config:
output_path: null
tensorboard_config:
output_path: null
container_logs_path: null
wait: True
inputs:
s3:
train: null
val: null
file_system:
directory_path: null
additional_estimator_kwargs:
max_run: 1800
```
1. `output_path`: Anda dapat menentukan di mana Anda menyimpan model Anda ke URL Amazon S3.
1. `tensorboard_config`: Anda dapat menentukan konfigurasi TensorBoard terkait seperti jalur keluaran atau jalur TensorBoard log.
1. `wait`: Anda dapat menentukan apakah Anda sedang menunggu pekerjaan selesai ketika Anda mengirimkan pekerjaan pelatihan Anda.
1. `inputs`: Anda dapat menentukan jalur untuk data pelatihan dan validasi Anda. Sumber data dapat berasal dari sistem file bersama seperti Amazon FSx atau URL Amazon S3.
1. `additional_estimator_kwargs`: Argumen estimator tambahan untuk mengirimkan pekerjaan pelatihan ke platform pekerjaan SageMaker pelatihan. Untuk informasi selengkapnya, lihat [Penaksir Algoritma](https://sagemaker.readthedocs.io/en/stable/api/training/algorithm.html).
# Pertimbangan-pertimbangan
Saat Anda menggunakan SageMaker HyperPod resep Amazon, ada beberapa faktor yang dapat memengaruhi proses pelatihan model.
+ `transformers`Versi harus `4.45.2` atau lebih besar untuk Llama 3.2. Jika Anda menggunakan alur kerja Slurm atau K8s, versi diperbarui secara otomatis.
+ Mixtral tidak mendukung presisi floating point 8-bit () FP8
+ Instans Amazon EC2 p4 tidak mendukung FP8
# Pengaturan lanjutan
Adaptor SageMaker HyperPod resep dibangun di atas kerangka kerja Nvidia Nemo dan Pytorch-Lightning. Jika Anda sudah menggunakan kerangka kerja ini, mengintegrasikan model atau fitur khusus Anda ke dalam adaptor SageMaker HyperPod resep adalah proses yang serupa. Selain memodifikasi adaptor resep, Anda dapat mengubah skrip pra-pelatihan atau fine-tuning Anda sendiri. Untuk panduan menulis skrip pelatihan khusus Anda, lihat [contoh](https://github.com/aws/sagemaker-hyperpod-training-adapter-for-nemo/tree/main/examples).
## Gunakan SageMaker HyperPod adaptor untuk membuat model Anda sendiri
Di dalam adaptor resep, Anda dapat menyesuaikan file berikut di lokasi berikut:
1. `collections/data`: Berisi modul yang bertanggung jawab untuk memuat kumpulan data. Saat ini, hanya mendukung kumpulan data dari. HuggingFace Jika Anda memiliki persyaratan yang lebih maju, struktur kode memungkinkan Anda untuk menambahkan modul data khusus dalam folder yang sama.
1. `collections/model`: Termasuk definisi berbagai model bahasa. Saat ini, ia mendukung model bahasa besar umum seperti Llama, Mixtral, dan Mistral. Anda memiliki fleksibilitas untuk memperkenalkan definisi model Anda sendiri dalam folder ini.
1. `collections/parts`: Folder ini berisi strategi untuk model pelatihan secara terdistribusi. Salah satu contohnya adalah strategi Fully Sharded Data Parallel (FSDP), yang memungkinkan untuk sharding model bahasa besar di beberapa akselerator. Selain itu, strategi mendukung berbagai bentuk paralelisme model. Anda juga memiliki opsi untuk memperkenalkan strategi pelatihan khusus Anda sendiri untuk pelatihan model.
1. `utils`: Berisi berbagai utilitas yang bertujuan memfasilitasi pengelolaan pekerjaan pelatihan. Ini berfungsi sebagai repositori di mana untuk alat Anda sendiri. Anda dapat menggunakan alat Anda sendiri untuk tugas-tugas seperti pemecahan masalah atau benchmarking. Anda juga dapat menambahkan callback PyTorch Lightning pribadi Anda sendiri dalam folder ini. Anda dapat menggunakan callback PyTorch Lightning untuk mengintegrasikan fungsionalitas atau operasi tertentu secara mulus ke dalam siklus hidup pelatihan.
1. `conf`: Berisi definisi skema konfigurasi yang digunakan untuk memvalidasi parameter tertentu dalam pekerjaan pelatihan. Jika Anda memperkenalkan parameter atau konfigurasi baru, Anda dapat menambahkan skema khusus Anda ke folder ini. Anda dapat menggunakan skema yang disesuaikan untuk menentukan aturan validasi. Anda dapat memvalidasi tipe data, rentang, atau batasan parameter lainnya. Anda juga dapat menentukan skema kustom Anda sendiri untuk memvalidasi parameter.
# Lampiran
Gunakan informasi berikut untuk mendapatkan informasi tentang pemantauan dan analisis hasil pelatihan.
## Pantau hasil pelatihan
Memantau dan menganalisis hasil pelatihan sangat penting bagi pengembang untuk menilai konvergensi dan memecahkan masalah. SageMaker HyperPod resep menawarkan integrasi Tensorboard untuk menganalisis perilaku pelatihan. Untuk mengatasi tantangan pembuatan profil pekerjaan pelatihan terdistribusi besar, resep ini juga disertakan. VizTracer VizTraceradalah alat overhead rendah untuk melacak dan memvisualisasikan eksekusi kode Python. Untuk informasi lebih lanjut tentang VizTracer, lihat [VizTracer](https://viztracer.readthedocs.io/en/latest/installation.html).
Bagian berikut memandu Anda melalui proses penerapan fitur-fitur ini dalam SageMaker HyperPod resep Anda.
### Tensorboard
Tensorboard adalah alat yang ampuh untuk memvisualisasikan dan menganalisis proses pelatihan. Untuk mengaktifkan Tensorboard, ubah resep Anda dengan menyetel parameter berikut:
```
exp_manager:
exp_dir: null
name: experiment
create_tensorboard_logger: True
```
Setelah Anda mengaktifkan logger Tensorboard, log pelatihan dibuat dan disimpan dalam direktori eksperimen. Eksperimen yang diarahkan didefinisikan dalam exp\$1manager.exp\$1dir. Untuk mengakses dan menganalisis log ini secara lokal, gunakan prosedur berikut:
**Untuk mengakses dan menganalisis log**
1. Unduh folder eksperimen Tensorboard dari lingkungan pelatihan Anda ke mesin lokal Anda.
1. Buka terminal atau command prompt pada mesin lokal Anda.
1. Arahkan ke direktori yang berisi folder eksperimen yang diunduh.
1. Luncurkan Tensorboard dengan mengikuti perintah.
```
tensorboard --port= --bind_all --logdir experiment.
```
1. Buka browser web Anda dan kunjungi http://localhost:8008.
Anda sekarang dapat melihat status dan visualisasi pekerjaan pelatihan Anda dalam antarmuka Tensorboard. Melihat status dan visualisasi membantu Anda memantau dan menganalisis proses pelatihan. Memantau dan menganalisis proses pelatihan membantu Anda mendapatkan wawasan tentang perilaku dan kinerja model Anda. Untuk informasi selengkapnya tentang cara Anda memantau dan menganalisis pelatihan dengan Tensorboard, lihat [Panduan Pengguna NVIDIA NeMo Framework](https://docs.nvidia.com/nemo-framework/user-guide/latest/llms/index.html).
### VizTracer
Untuk mengaktifkan VizTracer, Anda dapat memodifikasi resep Anda dengan menyetel parameter model.viztracer.enabled ke true. Misalnya, Anda dapat memperbarui resep llama Anda untuk mengaktifkan VizTracer dengan menambahkan konfigurasi berikut:
```
model:
viztracer:
enabled: true
```
Setelah pelatihan selesai, VizTracer profil Anda ada di folder eksperimen exp\$1dir/result.json. Untuk menganalisis profil Anda, Anda dapat mengunduhnya dan membukanya menggunakan alat vizviewer:
```
vizviewer --port result.json
```
Perintah ini meluncurkan vizviewer pada port 9001. Anda dapat melihat Anda VizTracer dengan menentukan http://localhost: di browser Anda. Setelah Anda membuka VizTracer, Anda mulai menganalisis pelatihan. Untuk informasi selengkapnya tentang penggunaan VizTracer, lihat VizTracer dokumentasi.
## SageMaker JumpStart versus SageMaker HyperPod
Sementara SageMaker JumpStart menyediakan kemampuan fine-tuning, SageMaker HyperPod resep menyediakan yang berikut:
+ Kontrol berbutir halus tambahan atas loop pelatihan
+ Kustomisasi resep untuk model dan data Anda sendiri
+ Support untuk paralelisme model
Gunakan SageMaker HyperPod resep saat Anda memerlukan akses ke hyperparameters model, pelatihan multi-node, dan opsi penyesuaian untuk loop pelatihan.
Untuk informasi selengkapnya tentang menyempurnakan model Anda, lihat SageMaker JumpStart [Sempurnakan model foundation yang tersedia untuk umum dengan kelasnya `JumpStartEstimator`](jumpstart-foundation-models-use-python-sdk-estimator-class.md)