Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutoriales
Los siguientes tutoriales de inicio rápido le ayudan a comenzar a utilizar las fórmulas de entrenamiento:
+ SageMaker HyperPod con Slurm Orchestration
+ Entrenamiento previo
+ [HyperPod Tutorial de preentrenamiento de Slurm Cluster (GPU)](hyperpod-gpu-slurm-pretrain-tutorial.md)
+ [Tutorial de entrenamiento previo del clúster Trainium de Slurm](hyperpod-trainium-slurm-cluster-pretrain-tutorial.md)
+ Ajuste
+ [HyperPod Tutorial de Lora (GPU) sobre el clúster Slurm](hyperpod-gpu-slurm-peft-lora-tutorial.md)
+ [HyperPod Tutorial de DPO de Slurm Cluster (GPU)](hyperpod-gpu-slurm-dpo-tutorial.md)
+ SageMaker HyperPod con K8s Orchestration
+ Entrenamiento previo
+ [Tutorial de entrenamiento previo con clústeres de Kubernetes (GPU)](sagemaker-hyperpod-gpu-kubernetes-cluster-pretrain-tutorial.md)
+ [Tutorial previo a los trabajos de SageMaker formación de Trainium](sagemaker-hyperpod-trainium-sagemaker-training-jobs-pretrain-tutorial.md)
+ SageMaker trabajos de formación
+ Entrenamiento previo
+ [SageMaker tutoriales previos a la formación para trabajos de formación (GPU)](sagemaker-hyperpod-gpu-sagemaker-training-jobs-pretrain-tutorial.md)
+ [Tutorial previo a los trabajos de SageMaker formación de Trainium](sagemaker-hyperpod-trainium-sagemaker-training-jobs-pretrain-tutorial.md)
# HyperPod Tutorial de preentrenamiento de Slurm Cluster (GPU)
El siguiente tutorial configura el entorno de Slurm y comienza un trabajo de entrenamiento en un modelo de 8000 millones de parámetros de Llama.
**Requisitos previos**
Antes de configurar el entorno para ejecutar la fórmula, asegúrese de haber hecho lo siguiente:
Configura un clúster Slurm de HyperPod GPU.
Tu clúster de HyperPod Slurm debe tener activados Nvidia Enroot y Pyxis (están activados de forma predeterminada).
Una ubicación de almacenamiento compartida. Puede ser un sistema de FSx archivos Amazon o un sistema NFS al que se pueda acceder desde los nodos del clúster.
Datos en uno de los siguientes formatos:
JSON
JSONGZ (JSON comprimido)
ARROW
(Opcional) Debes obtener un HuggingFace token si utilizas las pesas del modelo HuggingFace para realizar un entrenamiento previo o realizar ajustes. Para obtener más información sobre cómo obtener el token, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens).
## HyperPod Configuración del entorno GPU Slurm
Para iniciar un trabajo de formación en un clúster de HyperPod GPU Slurm, haga lo siguiente:
1. SSH en el nodo principal del clúster de Slurm.
1. Después de iniciar sesión, configure el entorno virtual. Asegúrese de utilizar Python 3.9 o posterior.
```
#set up a virtual environment
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
1. Clona los repositorios de SageMaker HyperPod recetas y SageMaker HyperPod adaptadores en una ubicación de almacenamiento compartida.
```
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. Cree un archivo squash con Enroot. Para buscar la versión más reciente del contenedor de SMP, consulte [Notas de publicación de la biblioteca de paralelismo de SageMaker modelos](model-parallel-release-notes.md). Para comprender mejor cómo usar el archivo Enroot, consulte la imagen de [AWS Nemo-Launcher optimizada para compilar](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/"
```
1. Para usar el archivo squash de Enroot para empezar a entrenar, utilice el siguiente ejemplo para modificar el archivo `recipes_collection/config.yaml`.
```
container: /fsx/path/to/your/smdistributed-modelparallel.sqsh
```
## Lanzamiento del trabajo de entrenamiento
Tras instalar las dependencias, lance un trabajo de entrenamiento desde el directorio `sagemaker-hyperpod-recipes/launcher_scripts`. [Las dependencias se obtienen clonando el repositorio de recetas: SageMaker HyperPod ](https://github.com/aws/sagemaker-hyperpod-recipes)
En primer lugar, elija su fórmula de entrenamiento en Github; el nombre del modelo se especifica en la fórmula. En el siguiente ejemplo, utilizamos el script `launcher_scripts/llama/run_hf_llama3_8b_seq16k_gpu_p5x16_pretrain.sh` para lanzar una fórmula de entrenamiento previo de Llama 8b con una longitud de secuencia de 8192: `llama/hf_llama3_8b_seq16k_gpu_p5x16_pretrain`.
+ `IMAGE`: es el contenedor de la sección de configuración del entorno.
+ (Opcional) Puedes proporcionar el HuggingFace token si necesitas pesos previamente entrenados HuggingFace configurando el siguiente par clave-valor:
```
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"
```
Después de configurar todos los parámetros necesarios en el script del lanzador, puede ejecutar el script con el siguiente comando.
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq16k_gpu_p5x16_pretrain.sh
```
Para obtener más información acerca de la configuración del clúster de Slurm, consulte [¿Estás realizando un trabajo de formación en HyperPod Slurm](cluster-specific-configurations-run-training-job-hyperpod-slurm.md).
# Tutorial de entrenamiento previo del clúster Trainium de Slurm
En el siguiente tutorial se muestra cómo configurar el entorno de Trainium en un clúster de Slurm y lanzar un trabajo de entrenamiento en un modelo de 8000 millones de parámetros de Llama.
**Requisitos previos**
Antes de configurar el entorno, asegúrese de disponer de:
Configure un clúster de SageMaker HyperPod Trainium Slurm.
Una ubicación de almacenamiento compartida. Puede ser un sistema de FSx archivos Amazon o un sistema NFS al que se pueda acceder desde los nodos del clúster.
Datos en uno de los siguientes formatos:
JSON
JSONGZ (JSON comprimido)
ARROW
(Opcional) Debes obtener un HuggingFace token si utilizas las pesas del modelo para el entrenamiento previo o HuggingFace para realizar ajustes. Para obtener más información sobre cómo obtener el token, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens).
## Configuración del entorno de Trainium en el clúster de Slurm
Para iniciar un trabajo de entrenamiento en un clúster de Slurm, haga lo siguiente:
+ SSH en el nodo principal del clúster de Slurm.
+ Después de iniciar sesión, configure el entorno de Neuron. Para obtener más información sobre la configuración de Neuron, consulte los [pasos de configuración de Neuron](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/libraries/nxd-training/tutorials/hf_llama3_8B_SFT.html#setting-up-the-environment). Recomendamos que confíe en las AMI de aprendizaje profundo preinstaladas con los controladores de Neuron, como [Ubuntu 20 con DLAMI Pytorch](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).
+ Clona el repositorio de SageMaker HyperPod recetas en una ubicación de almacenamiento compartida del clúster. La ubicación de almacenamiento compartido puede ser un sistema de FSx archivos Amazon o un sistema NFS al que se pueda acceder desde los nodos del clúster.
```
git clone --recursive https://github.com/aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
+ Siga el siguiente tutorial: Capacitación previa sobre [HuggingFace Llama3-8B](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/libraries/nxd-training/tutorials/hf_llama3_8B_pretraining.html#)
+ Prepare la configuración de un modelo. Las configuraciones de modelos están disponibles en el repositorio de Neuron. Para ver la configuración del modelo utilizada en este tutorial, consulte [llama3 8b model config](https://github.com/aws-neuron/neuronx-distributed/blob/main/examples/training/llama/tp_zero1_llama_hf_pretrain/8B_config_llama3/config.json).
## Lanzamiento del trabajo de entrenamiento en Trainium
Para iniciar un trabajo de entrenamiento en Trainium, especifique una configuración de clúster y una fórmula de Neuron. Por ejemplo, para lanzar un trabajo de entrenamiento previo de llama3 8b en Trainium, defina el script de lanzamiento, `launcher_scripts/llama/run_hf_llama3_8b_seq8k_trn1x4_pretrain.sh`, de la siguiente manera:
+ `MODEL_CONFIG`: es el modelo de configuración de la sección de configuración del entorno.
+ (Opcional) Puedes proporcionar el HuggingFace token si necesitas pesas previamente entrenadas HuggingFace configurando el siguiente par clave-valor:
```
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"
```
Para iniciar el trabajo de entrenamiento, ejecute el siguiente comando:
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq8k_trn1x4_pretrain.sh
```
Para obtener más información acerca de la configuración del clúster de Slurm, consulte [¿Estás realizando un trabajo de formación en HyperPod Slurm](cluster-specific-configurations-run-training-job-hyperpod-slurm.md).
# HyperPod Tutorial de DPO de Slurm Cluster (GPU)
En el siguiente tutorial se configura el entorno de Slurm y comienza un trabajo de optimización de preferencias directas (DPO, por sus siglas en inglés) en un modelo de 8000 millones de parámetros de Llama.
**Requisitos previos**
Antes de configurar el entorno, asegúrese de disponer de:
Configure el clúster Slurm de GPU HyperPod
Tu clúster de HyperPod Slurm debe tener activados Nvidia Enroot y Pyxis (están activados de forma predeterminada).
Una ubicación de almacenamiento compartida. Puede ser un sistema de FSx archivos Amazon o un sistema NFS al que se pueda acceder desde los nodos del clúster.
Un conjunto de datos de preferencias binarias tokenizado en uno de los siguientes formatos:
JSON
JSONGZ (JSON comprimido)
ARROW
(Opcional) Si necesitas las pesas previamente entrenadas HuggingFace o si estás entrenando un modelo Llama 3.2, debes obtener la HuggingFace ficha antes de empezar a entrenar. Para obtener más información sobre cómo obtener el token, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens).
## Configura el entorno HyperPod GPU Slurm
Para iniciar un trabajo de entrenamiento en un clúster de Slurm, haga lo siguiente:
+ SSH en el nodo principal del clúster de Slurm.
+ Después de iniciar sesión, configure el entorno virtual. Asegúrese de utilizar Python 3.9 o posterior.
```
#set up a virtual environment
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
+ Clona las SageMaker HyperPod recetas y los repositorios de SageMaker HyperPod adaptadores en una ubicación de almacenamiento compartida. La ubicación de almacenamiento compartido puede ser un sistema de FSx archivos Amazon o un sistema NFS al que se pueda acceder desde los nodos del clúster.
```
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
```
+ Cree un archivo squash con Enroot. Para buscar la versión más reciente del contenedor de SMP, consulte [Notas de publicación de la biblioteca de paralelismo de SageMaker modelos](model-parallel-release-notes.md). Para obtener más información sobre el uso del archivo Enroot, consulte la imagen de [AWS Nemo-Launcher optimizada para compilar](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/"
```
+ Para usar el archivo squash de Enroot para empezar a entrenar, utilice el siguiente ejemplo para modificar el archivo `recipes_collection/config.yaml`.
```
container: /fsx/path/to/your/smdistributed-modelparallel.sqsh
```
## Lanzamiento del trabajo de entrenamiento
Para lanzar un trabajo de DPO para el modelo de 8000 millones de parámetros de Llama con una longitud de secuencia de 8192 en un único nodo de computación de Slurm, defina el script de lanzamiento `launcher_scripts/llama/run_hf_llama3_8b_seq8k_gpu_dpo.sh` de la siguiente manera:
+ `IMAGE`: es el contenedor de la sección de configuración del entorno.
+ `HF_MODEL_NAME_OR_PATH`: defina el nombre o la ruta de las ponderaciones entrenadas previamente en el parámetro hf\$1model\$1name\$1or\$1path de la fórmula.
+ (Opcional) Puedes proporcionar el HuggingFace token si necesitas pesas previamente entrenadas configurando el siguiente par clave-valor: HuggingFace
```
recipes.model.hf_access_token=${HF_ACCESS_TOKEN}
```
**nota**
El modelo de referencia utilizado para la DPO en esta configuración se deriva automáticamente del modelo base que se está entrenando (no se define explícitamente ningún modelo de referencia independiente). Los hiperparámetros específicos de la DPO se han configurado previamente con los siguientes valores predeterminados:
`beta`: 0,1 (controla la intensidad de la regularización de la divergencia KL)
`label_smoothing`: 0,0 (no se suaviza ninguna etiqueta de preferencias)
```
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}$" \
```
Tras configurar todos los parámetros necesarios en el script anterior, puede iniciar el trabajo de entrenamiento ejecutándolo.
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq8k_gpu_dpo.sh
```
Para obtener más información acerca de la configuración del clúster de Slurm, consulte [¿Estás realizando un trabajo de formación en HyperPod Slurm](cluster-specific-configurations-run-training-job-hyperpod-slurm.md).
# HyperPod Tutorial de Lora (GPU) sobre el clúster Slurm
En el siguiente tutorial se muestra cómo configurar el entorno de Slurm y cómo se inicia un trabajo de refinamiento eficiente en parámetros (PEFT, por sus siglas en inglés) en un modelo de 8000 millones de parámetros de Llama.
**Requisitos previos**
Antes de configurar el entorno, asegúrese de disponer de:
Configure HyperPod el clúster Slurm de GPU
Tu clúster de HyperPod Slurm debe tener activados Nvidia Enroot y Pyxis (están activados de forma predeterminada).
Una ubicación de almacenamiento compartida. Puede ser un sistema de FSx archivos Amazon o un sistema NFS al que se pueda acceder desde los nodos del clúster.
Datos en uno de los siguientes formatos:
JSON
JSONGZ (JSON comprimido)
ARROW
(Opcional) Si necesitas las pesas previamente entrenadas HuggingFace o si estás entrenando un modelo Llama 3.2, debes obtener la HuggingFace ficha antes de empezar a entrenar. Para obtener más información sobre cómo obtener el token, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens).
## Configura el entorno HyperPod GPU Slurm
Para iniciar un trabajo de entrenamiento en un clúster de Slurm, haga lo siguiente:
+ SSH en el nodo principal del clúster de Slurm.
+ Después de iniciar sesión, configure el entorno virtual. Asegúrese de utilizar Python 3.9 o posterior.
```
#set up a virtual environment
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
+ Clona las SageMaker HyperPod recetas y los repositorios de SageMaker HyperPod adaptadores en una ubicación de almacenamiento compartida. La ubicación de almacenamiento compartido puede ser un sistema de FSx archivos Amazon o un sistema NFS al que se pueda acceder desde los nodos del clúster.
```
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
```
+ Cree un archivo squash con Enroot. Para buscar la versión más reciente del contenedor de SMP, consulte [Notas de publicación de la biblioteca de paralelismo de SageMaker modelos](model-parallel-release-notes.md). Para obtener más información sobre el uso del archivo Enroot, consulte la imagen de [AWS Nemo-Launcher optimizada para compilar](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/"
```
+ Para usar el archivo squash de Enroot para empezar a entrenar, utilice el siguiente ejemplo para modificar el archivo `recipes_collection/config.yaml`.
```
container: /fsx/path/to/your/smdistributed-modelparallel.sqsh
```
## Lanzamiento del trabajo de entrenamiento
Para lanzar un trabajo de PEFT para el modelo de 8000 millones de parámetros de Llama con una longitud de secuencia de 8192 en un único nodo de computación de Slurm, defina el script de lanzamiento `launcher_scripts/llama/run_hf_llama3_8b_seq8k_gpu_lora.sh` de la siguiente manera:
+ `IMAGE`: es el contenedor de la sección de configuración del entorno.
+ `HF_MODEL_NAME_OR_PATH`: defina el nombre o la ruta de las ponderaciones entrenadas previamente en el parámetro hf\$1model\$1name\$1or\$1path de la fórmula.
+ (Opcional) Puedes proporcionar el HuggingFace token si necesitas pesas previamente entrenadas configurando el siguiente par clave-valor: HuggingFace
```
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}"
```
Tras configurar todos los parámetros necesarios en el script anterior, puede iniciar el trabajo de entrenamiento ejecutándolo.
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq8k_gpu_lora.sh
```
Para obtener más información acerca de la configuración del clúster de Slurm, consulte [¿Estás realizando un trabajo de formación en HyperPod Slurm](cluster-specific-configurations-run-training-job-hyperpod-slurm.md).
# Tutorial de entrenamiento previo con clústeres de Kubernetes (GPU)
Hay dos formas de iniciar un trabajo de entrenamiento de GPU en un clúster de Kubernetes:
+ [Herramienta de línea de comandos (recomendada) HyperPod ](https://github.com/aws/sagemaker-hyperpod-cli)
+ El NeMo lanzador de estilos
**Requisitos previos**
Antes de configurar el entorno, asegúrese de disponer de:
Un clúster HyperPod de Kubernetes con GPU está configurado correctamente.
Una ubicación de almacenamiento compartida. Puede ser un sistema de FSx archivos Amazon o un sistema NFS al que se pueda acceder desde los nodos del clúster.
Datos en uno de los siguientes formatos:
JSON
JSONGZ (JSON comprimido)
ARROW
(Opcional) Debes obtener un HuggingFace token si utilizas las pesas del modelo para el entrenamiento previo o HuggingFace para realizar ajustes. Para obtener más información sobre cómo obtener el token, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens).
## Configuración del entorno de GPU Kubernetes
Para configurar un entorno de GPU Kubernetes, haga lo siguiente:
+ Configure el entorno virtual. Asegúrese de utilizar Python 3.9 o posterior.
```
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
+ Instale las dependencias siguiendo uno de estos métodos:
+ (Recomendado): método de herramienta de línea de [HyperPod comandos](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 método de recetas:
```
# install SageMaker HyperPod Recipes.
git clone --recursive git@github.com:aws/sagemaker-hyperpod-recipes.git
cd sagemaker-hyperpod-recipes
pip3 install -r requirements.txt
```
+ [Configure kubectl y eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html).
+ [Instale Helm](https://helm.sh/docs/intro/install/).
+ Conéctese con su clúster de Kubernetes.
```
aws eks update-kubeconfig --region "CLUSTER_REGION" --name "CLUSTER_NAME"
hyperpod connect-cluster --cluster-name "CLUSTER_NAME" [--region "CLUSTER_REGION"] [--namespace ]
```
## Inicie el trabajo de formación con la SageMaker HyperPod CLI
Recomendamos utilizar la herramienta de interfaz SageMaker HyperPod de línea de comandos (CLI) para enviar el trabajo de formación con las configuraciones. En el siguiente ejemplo, se envía un trabajo de entrenamiento para el modelo `hf_llama3_8b_seq16k_gpu_p5x16_pretrain`.
+ `your_training_container`: es un contenedor de aprendizaje profundo. Para buscar la versión más reciente del contenedor de SMP, consulte [Notas de publicación de la biblioteca de paralelismo de SageMaker modelos](model-parallel-release-notes.md).
+ (Opcional) Puedes proporcionar el HuggingFace token si necesitas pesas previamente entrenadas HuggingFace configurando el siguiente par clave-valor:
```
"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"
}'
```
Después de enviar un trabajo de entrenamiento, puede usar el siguiente comando para comprobar si lo ha enviado correctamente.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
hf-llama3--worker-0 0/1 running 0 36s
```
Si el `STATUS` es `PENDING` o `ContainerCreating`, ejecute el siguiente comando para obtener más información.
```
kubectl describe pod name_of_pod
```
Cuando el `STATUS` del trabajo cambie a `Running`, podrá examinar el registro con el siguiente comando.
```
kubectl logs name_of_pod
```
El `STATUS` cambia a `Completed` si ejecuta `kubectl get pods`.
## Lanzamiento del trabajo de entrenamiento con el lanzador de fórmulas
Como alternativa, puedes usar las SageMaker HyperPod recetas para enviar tu trabajo de entrenamiento. Usar fórmulas implica actualizar `k8s.yaml`, `config.yaml` y ejecutar el script de lanzamiento.
+ En `k8s.yaml`, actualice `persistent_volume_claims`. Coloca la FSx reclamación de Amazon en el `/data` directorio de cada módulo de computación
```
persistent_volume_claims:
- claimName: fsx-claim
mountPath: data
```
+ En `config.yaml`, actualice `repo_url_or_path` en `git`.
```
git:
repo_url_or_path:
branch: null
commit: null
entry_script: null
token: null
```
+ Actualice `launcher_scripts/llama/run_hf_llama3_8b_seq16k_gpu_p5x16_pretrain.sh`.
+ `your_contrainer`: es un contenedor de aprendizaje profundo. Para buscar la versión más reciente del contenedor de SMP, consulte [Notas de publicación de la biblioteca de paralelismo de SageMaker modelos](model-parallel-release-notes.md).
+ (Opcional) Puede proporcionar el HuggingFace token si necesita pesos previamente entrenados HuggingFace configurando el siguiente par clave-valor:
```
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
```
+ Lanzamiento del trabajo de entrenamiento
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq16k_gpu_p5x16_pretrain.sh
```
Después de enviar el trabajo de entrenamiento, puede usar el siguiente comando para comprobar si lo ha enviado correctamente.
```
kubectl get pods
```
```
NAME READY STATUS RESTARTS AGE
hf-llama3--worker-0 0/1 running 0 36s
```
Si el `STATUS` es `PENDING` o `ContainerCreating`, ejecute el siguiente comando para obtener más información.
```
kubectl describe pod
```
Cuando el `STATUS` del trabajo cambie a `Running`, podrá examinar el registro con el siguiente comando.
```
kubectl logs name_of_pod
```
El `STATUS` pasará a `Completed` cuando ejecute `kubectl get pods`.
Para obtener más información acerca de la configuración del clúster k8s, consulte [¿Estás realizando un trabajo de entrenamiento en k8s HyperPod](cluster-specific-configurations-run-training-job-hyperpod-k8s.md).
# Tutorial de entrenamiento previo del clúster Trainium de Kubernetes
Puede utilizar uno de los métodos siguientes para lanzar un trabajo de entrenamiento en un clúster Trainium de Kubernetes.
+ [Herramienta de línea de comandos (recomendada) HyperPod ](https://github.com/aws/sagemaker-hyperpod-cli)
+ El NeMo lanzador de estilos
**Requisitos previos**
Antes de configurar el entorno, asegúrese de disponer de:
Configura un clúster de HyperPod Trainium Kubernetes
Una ubicación de almacenamiento compartido que puede ser un sistema de FSx archivos Amazon o un sistema NFS al que se pueda acceder desde los nodos del clúster.
Datos en uno de los siguientes formatos:
JSON
JSONGZ (JSON comprimido)
ARROW
(Opcional) Debes obtener un HuggingFace token si vas a utilizar las pesas del modelo para el entrenamiento previo o HuggingFace para realizar ajustes. Para obtener más información sobre cómo obtener el token, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens).
## Configuración del entorno de Trainium Kubernetes
Para configurar un entorno de Trainium Kubernetes, haga lo siguiente:
1. **Complete los pasos del siguiente tutorial: Entrenamiento previo de [HuggingFace Llama3-8B](https://awsdocs-neuron.readthedocs-hosted.com/en/latest/libraries/nxd-training/tutorials/hf_llama3_8B_pretraining.html#download-the-dataset) a partir de Descargar el conjunto de datos.**
1. Prepare la configuración de un modelo. Están disponibles en el repositorio de Neuron. Para este tutorial, puede utilizar la configuración del modelo llama3 8b.
1. Configure el entorno virtual. Asegúrese de utilizar Python 3.9 o posterior.
```
python3 -m venv ${PWD}/venv
source venv/bin/activate
```
1. Instale las dependencias.
+ (Recomendado) Utilice la siguiente herramienta de línea de comandos HyperPod
```
# install HyperPod command line tools
git clone https://github.com/aws/sagemaker-hyperpod-cli
cd sagemaker-hyperpod-cli
pip3 install .
```
+ Si usa SageMaker HyperPod recetas, especifique lo siguiente
```
# 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. [Configure kubectl y eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html).
1. [Instale Helm](https://helm.sh/docs/intro/install/).
1. Conéctese con su clúster de Kubernetes.
```
aws eks update-kubeconfig --region "${CLUSTER_REGION}" --name "${CLUSTER_NAME}"
hyperpod connect-cluster --cluster-name "${CLUSTER_NAME}" [--region "${CLUSTER_REGION}"] [--namespace ]
```
1. Contenedor: el [Neuron container](https://github.com/aws-neuron/deep-learning-containers?tab=readme-ov-file#pytorch-training-neuronx).
## Inicie el trabajo de formación con la SageMaker HyperPod CLI
Recomendamos utilizar la herramienta de interfaz SageMaker HyperPod de línea de comandos (CLI) para enviar el trabajo de formación con las configuraciones. En el siguiente ejemplo, se envía un trabajo de entrenamiento para el modelo `hf_llama3_8b_seq8k_trn1x4_pretrain` de Trainium.
+ `your_neuron_container`: es el [Neuron container](https://github.com/aws-neuron/deep-learning-containers?tab=readme-ov-file#pytorch-training-neuronx).
+ `your_model_config`: es el modelo de configuración de la sección de configuración del entorno.
+ (Opcional) Puedes proporcionar el HuggingFace token si necesitas pesas previamente entrenadas HuggingFace configurando el siguiente par clave-valor:
```
"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": ""
}'
```
Después de enviar un trabajo de entrenamiento, puede usar el siguiente comando para comprobar si lo ha enviado correctamente.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
hf-llama3--worker-0 0/1 running 0 36s
```
Si el `STATUS` es `PENDING` o `ContainerCreating`, ejecute el siguiente comando para obtener más información.
```
kubectl describe pod name_of_pod
```
Cuando el `STATUS` del trabajo cambie a `Running`, podrá examinar el registro con el siguiente comando.
```
kubectl logs name_of_pod
```
El `STATUS` pasará a `Completed` cuando ejecute `kubectl get pods`.
## Lanzamiento del trabajo de entrenamiento con el lanzador de fórmulas
También puedes usar SageMaker HyperPod recetas para enviar tu trabajo de entrenamiento. Para enviar el trabajo de entrenamiento con una fórmula, actualice `k8s.yaml` y `config.yaml`. Ejecute el script de bash para que el modelo lo lance.
+ En`k8s.yaml`, actualiza persistent\$1volume\$1claims para montar la reclamación de FSx Amazon en el directorio /data de los nodos de cómputo
```
persistent_volume_claims:
- claimName: fsx-claim
mountPath: data
```
+ scripts/llama/runActualice launcher\$1 \$1hf\$1llama3\$18b\$1seq8k\$1trn1x4\$1pretrain.sh
+ `your_neuron_contrainer`: es el contenedor de la sección de configuración del entorno.
+ `your_model_config`: es el modelo de configuración de la sección de configuración del entorno.
(Opcional) Puede proporcionar el HuggingFace token si necesita pesos previamente entrenados HuggingFace configurando el siguiente par clave-valor:
```
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
```
+ Lance el trabajo.
```
bash launcher_scripts/llama/run_hf_llama3_8b_seq8k_trn1x4_pretrain.sh
```
Después de enviar un trabajo de entrenamiento, puede usar el siguiente comando para comprobar si lo ha enviado correctamente.
```
kubectl get pods
NAME READY STATUS RESTARTS AGE
hf-llama3--worker-0 0/1 running 0 36s
```
Si el `STATUS` es `PENDING` o `ContainerCreating`, ejecute el siguiente comando para obtener más información.
```
kubectl describe pod name_of_pod
```
Cuando el STATUS del trabajo cambie a Running, podrá examinar el registro con el siguiente comando.
```
kubectl logs name_of_pod
```
El `STATUS` pasará a `Completed` cuando ejecute `kubectl get pods`.
Para obtener más información acerca de la configuración del clúster k8s, consulte [Tutorial de entrenamiento previo del clúster Trainium de Kubernetes](#sagemaker-hyperpod-trainium-kubernetes-cluster-pretrain-tutorial).
# SageMaker tutoriales previos a la formación para trabajos de formación (GPU)
Este tutorial le guía a través del proceso de configuración y ejecución de un trabajo previo a la formación mediante trabajos de SageMaker formación con instancias de GPU.
+ Configure su entorno
+ Lanza un trabajo de formación con recetas SageMaker HyperPod
Antes de comenzar, asegúrese de que cumple los siguientes requisitos previos.
**Requisitos previos**
Antes de configurar el entorno, asegúrese de disponer de:
Sistema de FSx archivos Amazon o un depósito de Amazon S3 donde puede cargar los datos y generar los artefactos de entrenamiento.
Solicitó una cuota de servicio para 1 ml.p4d.24xlarge y 1 ml.p5.48xlarge en Amazon AI. SageMaker Para solicitar un aumento de la cuota de servicio, haga lo siguiente:
En la consola AWS Service Quotas, vaya a AWS los servicios,
Elige **Amazon SageMaker AI**.
Elija una instancia de ml.p4d.24xlarge y una instancia de ml.p5.48xlarge.
Cree un rol AWS Identity and Access Management(de IAM) con las siguientes políticas administradas para conceder a la SageMaker IA los permisos necesarios para ejecutar los ejemplos.
AmazonSageMakerFullAccess
Amazon EC2 FullAccess
Datos en uno de los siguientes formatos:
JSON
JSONGZ (JSON comprimido)
ARROW
(Opcional) Debes obtener una HuggingFace ficha si utilizas las pesas del modelo para el entrenamiento previo o HuggingFace para ajustarlas con precisión. Para obtener más información sobre cómo obtener el token, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens).
## Configuración del entorno de trabajos de SageMaker entrenamiento con GPU
Antes de ejecutar un trabajo de SageMaker formación, configure sus AWS credenciales y su región preferida ejecutando el `aws configure` comando. Como alternativa al comando configure, puede proporcionar sus credenciales a través de variables de entorno como `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, y `AWS_SESSION_TOKEN.` para obtener más información, consulte [SageMaker AI Python SDK](https://github.com/aws/sagemaker-python-sdk).
Recomendamos encarecidamente utilizar un SageMaker cuaderno Jupyter de SageMaker IA JupyterLab para iniciar un trabajo de SageMaker formación. Para obtener más información, consulte [SageMaker JupyterLab](studio-updated-jl.md).
+ (Opcional) Configure el entorno virtual y las dependencias. Si utilizas una libreta Jupyter en Amazon SageMaker Studio, puedes saltarte este paso. Asegúrese de utilizar Python 3.9 o posterior.
```
# 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
```
+ Instale SageMaker AI Python SDK
```
pip3 install --upgrade sagemaker
```
+ `Container`: el SDK de Python para SageMaker IA configura automáticamente el contenedor de GPU. También puede proporcionar su propio contenedor.
**nota**
Si está ejecutando un trabajo de entrenamiento multimodal en Llama 3.2, la versión de `transformers` debe ser `4.45.2 ` o superior.
`transformers==4.45.2``requirements.txt`Añádelo `source_dir` solo cuando utilices el SDK de Python para SageMaker IA. Por ejemplo, agréguelo si lo está utilizando en un cuaderno de IA. SageMaker JupyterLab
Si está utilizando HyperPod recetas para iniciar con el tipo de clúster`sm_jobs`, esto se realizará automáticamente.
## Lanzamiento del trabajo de entrenamiento con un cuaderno de Jupyter
Puedes usar el siguiente código de Python para ejecutar un trabajo de SageMaker entrenamiento con tu receta. Utiliza el PyTorch estimador del [SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/) para IA para enviar la receta. En el siguiente ejemplo, se lanza la receta llama3-8b en la plataforma AI Training. 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)
```
El código anterior crea un objeto PyTorch estimador con la receta de entrenamiento y, a continuación, ajusta el modelo mediante el método. `fit()` Utilice el parámetro training\$1recipe para especificar la receta que desee utilizar para el entrenamiento.
**nota**
Si está ejecutando un trabajo de entrenamiento multimodal en Llama 3.2, la versión de transformers debe ser 4.45.2 o superior.
`transformers==4.45.2`Añádelo `requirements.txt` `source_dir` solo cuando utilices el SDK de Python para SageMaker IA directamente. Por ejemplo, debe añadir la versión al archivo de texto cuando utilice un cuaderno de Jupyter.
Al implementar el punto final para un trabajo de SageMaker formación, debe especificar el URI de la imagen que está utilizando. Si no proporciona la URI de la imagen, el estimador utilizará la imagen de entrenamiento para la implementación. Las imágenes de entrenamiento que se SageMaker HyperPod proporcionan no contienen las dependencias necesarias para la inferencia y el despliegue. En el siguiente ejemplo se muestra cómo se puede utilizar una imagen de inferencia para la implementación:
```
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)
```
**nota**
Para ejecutar el código anterior en una instancia de portátil de Sagemaker, es posible que se necesiten más de los 5 GB de almacenamiento predeterminados que proporciona la IA. SageMaker JupyterLab Si tiene problemas por falta de espacio, cree una nueva instancia de cuaderno en la que debe utilizar una instancia de cuaderno diferente y aumente el almacenamiento del cuaderno.
## Lanzamiento del trabajo de entrenamiento con el lanzador de fórmulas
Actualice el archivo `./recipes_collection/cluster/sm_jobs.yaml` para que tenga el siguiente aspecto:
```
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: ""
```
Actualice `./recipes_collection/config.yaml` para que especifique `sm_jobs` en `cluster` y `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.
```
Lance el trabajo con el siguiente comando.
```
python3 main.py --config-path recipes_collection --config-name config
```
Para obtener más información sobre la configuración de los trabajos de SageMaker formación, consulte Ejecutar un trabajo de formación en los trabajos de SageMaker formación.
# Tutorial previo a los trabajos de SageMaker formación de Trainium
Este tutorial le guía a través del proceso de configuración y ejecución de un trabajo previo a la formación mediante trabajos de formación con instancias de SageMaker Trainium. AWS
+ Configure su entorno
+ Lanzamiento de un trabajo de entrenamiento
Antes de comenzar, asegúrese de que cumple los siguientes requisitos previos.
**Requisitos previos**
Antes de configurar el entorno, asegúrese de disponer de:
Sistema de FSx archivos Amazon o depósito S3 donde puede cargar los datos y generar los artefactos de entrenamiento.
Solicita una cuota de servicio para la `ml.trn1.32xlarge` instancia en Amazon SageMaker AI. Para solicitar un aumento de la cuota de servicio, haga lo siguiente:
Navegue a la consola AWS Service Quotas.
Elija AWS los servicios.
Selecciona JupyterLab.
Especifique una instancia para `ml.trn1.32xlarge`.
Cree un rol AWS Identity and Access Management (de IAM) con las políticas `AmazonEC2FullAccess` administradas `AmazonSageMakerFullAccess` y las políticas. Estas políticas proporcionan a Amazon SageMaker AI permisos para ejecutar los ejemplos.
Datos en uno de los siguientes formatos:
JSON
JSONGZ (JSON comprimido)
ARROW
(Opcional) Si necesitas las pesas previamente entrenadas HuggingFace o si estás entrenando un modelo Llama 3.2, debes obtener la HuggingFace ficha antes de empezar a entrenar. Para obtener más información sobre cómo obtener el token, consulte [User access tokens](https://huggingface.co/docs/hub/en/security-tokens).
## Configura tu entorno para los trabajos de entrenamiento de Trainium SageMaker
Antes de realizar un trabajo de SageMaker formación, utilice el `aws configure` comando para configurar sus AWS credenciales y su región preferida. Como alternativa, también puede proporcionar sus credenciales a través de variables de entorno como `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` y `AWS_SESSION_TOKEN`. Para obtener más información, consulte [SageMaker AI Python SDK](https://github.com/aws/sagemaker-python-sdk).
Recomendamos encarecidamente utilizar un cuaderno SageMaker AI Jupyter en SageMaker IA JupyterLab para iniciar un trabajo de SageMaker formación. Para obtener más información, consulte [SageMaker JupyterLab](studio-updated-jl.md).
+ (Opcional) Si utilizas el cuaderno Jupyter en Amazon SageMaker Studio, puedes omitir la ejecución del siguiente comando. Asegúrese de utilizar una versión >= 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
```
+ Instale SageMaker AI Python SDK
```
pip3 install --upgrade sagemaker
```
+
+ Si está ejecutando un trabajo de entrenamiento multimodal en Llama 3.2, la versión `transformers` debe ser `4.45.2` o superior.
+ `transformers==4.45.2`Añádelo a `requirements.txt` source\$1dir solo cuando utilices el SDK de SageMaker Python para IA.
+ Si utilizas HyperPod recetas para lanzarlas `sm_jobs` como tipo de clúster, no tienes que especificar la versión de los transformers.
+ `Container`: El SDK de SageMaker AI Python configura automáticamente el contenedor Neuron.
## Lanzamiento del trabajo de entrenamiento con un cuaderno de Jupyter
Puedes usar el siguiente código de Python para ejecutar un trabajo de SageMaker entrenamiento con tu receta. Utiliza el PyTorch estimador del [SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/) para IA para enviar la receta. El siguiente ejemplo lanza la receta llama3-8b como un trabajo de entrenamiento de IA SageMaker .
+ `compiler_cache_url`: es la caché que se utilizará para guardar los artefactos compilados, como un artefacto de 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)
```
El código anterior crea un objeto PyTorch estimador con la receta de entrenamiento y, a continuación, ajusta el modelo mediante el método. `fit()` Utilice el parámetro `training_recipe` para especificar la receta que desee utilizar para el entrenamiento.
## Lanzamiento del trabajo de entrenamiento con el lanzador de fórmulas
+ Actualice `./recipes_collection/cluster/sm_jobs.yaml`.
+ compiler\$1cache\$1url: es la URL utilizada para guardar los artefactos. Puede ser una URL de 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
```
+ Actualice `./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.
```
+ Lance el trabajo con `main.py`.
```
python3 main.py --config-path recipes_collection --config-name config
```
Para obtener más información sobre la configuración de los trabajos SageMaker de formación, consulte. [SageMaker tutoriales previos a la formación para trabajos de formación (GPU)](sagemaker-hyperpod-gpu-sagemaker-training-jobs-pretrain-tutorial.md)