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. # Ejecute trabajos PyTorch de entrenamiento con SageMaker Training Compiler Puede utilizar cualquiera de las interfaces de SageMaker IA para ejecutar un trabajo de formación con SageMaker Training Compiler: Amazon SageMaker Studio Classic, Amazon SageMaker Notebook instances y AWS Command Line Interface. AWS SDK para Python (Boto3) **Topics** + [Uso del SDK SageMaker de Python](#training-compiler-enable-pytorch-pysdk) + [Uso de la operación de la API de SageMaker IA `CreateTrainingJob`](#training-compiler-enable-pytorch-api) ## Uso del SDK SageMaker de Python SageMaker Training Compiler for PyTorch está disponible a través de las clases de SageMaker IA [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)y [https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html#hugging-face-estimator)Framework Estimator. Para activar SageMaker Training Compiler, añade el `compiler_config` parámetro a los estimadores de IA. SageMaker Importe la clase `TrainingCompilerConfig` y pase una instancia de ella al parámetro `compiler_config`. Los siguientes ejemplos de código muestran la estructura de las clases de estimadores de SageMaker IA con SageMaker Training Compiler activado. **sugerencia** Para empezar con los modelos prediseñados proporcionados por PyTorch Transformers, prueba a utilizar los tamaños de lote que se indican en la tabla de referencia de. [Modelos probados](training-compiler-support.md#training-compiler-tested-models) **nota** El PyTorch soporte nativo está disponible en el SDK de SageMaker Python v2.121.0 y versiones posteriores. Asegúrese de actualizar el SDK de SageMaker Python en consecuencia. **nota** A partir de la PyTorch versión 1.12.0, están disponibles los contenedores SageMaker Training Compiler para ellos. PyTorch Tenga en cuenta que los contenedores SageMaker Training Compiler para Hugging Face Transformers no PyTorch vienen preempaquetados. Si necesita instalar la biblioteca en el contenedor, asegúrese de añadir el archivo `requirements.txt` en el directorio de origen cuando envíe un trabajo de entrenamiento. Para la PyTorch versión 1.11.0 y anteriores, utilice las versiones anteriores de los contenedores SageMaker Training Compiler para Hugging Face y. PyTorch Para ver una lista completa de las versiones de marco y la información de contenedores correspondiente, consulte [Marcos admitidos](training-compiler-support.md#training-compiler-supported-frameworks). Para obtener información que se adapte a su caso de uso, consulte una de las siguientes opciones. ### Para el entrenamiento con una sola GPU ------ #### [ PyTorch v1.12.0 and later ] Para compilar y entrenar un PyTorch modelo, configure un PyTorch estimador de SageMaker IA con SageMaker Training Compiler, como se muestra en el siguiente ejemplo de código. **nota** Esta PyTorch compatibilidad nativa está disponible en el SDK de Python para SageMaker IA v2.120.0 y versiones posteriores. Asegúrese de actualizar el SDK de Python para SageMaker IA. ``` from sagemaker.pytorch import PyTorch, TrainingCompilerConfig # the original max batch size that can fit into GPU memory without compiler batch_size_native=12 learning_rate_native=float('5e-5') # an updated max batch size that can fit into GPU memory with compiler batch_size=64 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size hyperparameters={ "n_gpus": 1, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_estimator=PyTorch( entry_point='train.py', source_dir='path-to-requirements-file', # Optional. Add this if need to install additional packages. instance_count=1, instance_type='ml.p3.2xlarge', framework_version='1.13.1', py_version='py3', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) pytorch_estimator.fit() ``` ------ #### [ Hugging Face Transformers with PyTorch v1.11.0 and before ] Para compilar y entrenar un modelo de transformador PyTorch, configura un estimador SageMaker AI Hugging Face SageMaker con Training Compiler, como se muestra en el siguiente ejemplo de código. ``` from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig # the original max batch size that can fit into GPU memory without compiler batch_size_native=12 learning_rate_native=float('5e-5') # an updated max batch size that can fit into GPU memory with compiler batch_size=64 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size hyperparameters={ "n_gpus": 1, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_huggingface_estimator=HuggingFace( entry_point='train.py', instance_count=1, instance_type='ml.p3.2xlarge', transformers_version='4.21.1', pytorch_version='1.11.0', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) pytorch_huggingface_estimator.fit() ``` Para preparar su script de entrenamiento, consulte las siguientes páginas. + [Para el entrenamiento con una sola GPU](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-single-gpu)de un PyTorch modelo que utiliza la API Trainer de Hugging Face [Transformers](https://huggingface.co/docs/transformers/main_classes/trainer) + [Para el entrenamiento con una sola GPU](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-single-gpu)de un PyTorch modelo sin la API Trainer de Hugging Face [Transformers](https://huggingface.co/transformers/main_classes/trainer.html) Para encontrar end-to-end ejemplos, consulte los siguientes cuadernos: + [Compila y entrena un modelo de Hugging Face Transformers Trainer para hacer preguntas y respuestas con SQu el conjunto de datos de AD](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/albert-base-v2/albert-base-v2.html) + [Compila y entrena un modelo de Hugging Face `BERT` Transformer con el conjunto SageMaker de datos SST mediante Training Compiler](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/bert-base-cased/bert-base-cased-single-node-single-gpu.html) + [Compila y entrena un modelo de entrenamiento de clasificación binaria con el SST2 conjunto de datos para el entrenamiento con un solo nodo y una sola GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_single_gpu_single_node/roberta-base/roberta-base.html) ------ ### Para entrenamiento distribuido ------ #### [ PyTorch v1.12 ] Para la PyTorch versión 1.12, puede ejecutar un entrenamiento distribuido con SageMaker Training Compiler añadiendo la `pytorch_xla` opción especificada al `distribution` parámetro de la clase de estimador de IA. SageMaker PyTorch **nota** Esta PyTorch compatibilidad nativa está disponible en el SDK de Python para SageMaker IA v2.121.0 y versiones posteriores. Asegúrese de actualizar el SDK de Python para SageMaker IA. ``` from sagemaker.pytorch import PyTorch, TrainingCompilerConfig # choose an instance type, specify the number of instances you want to use, # and set the num_gpus variable the number of GPUs per instance. instance_count=1 instance_type='ml.p3.8xlarge' num_gpus=4 # the original max batch size that can fit to GPU memory without compiler batch_size_native=16 learning_rate_native=float('5e-5') # an updated max batch size that can fit to GPU memory with compiler batch_size=26 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count hyperparameters={ "n_gpus": num_gpus, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_estimator=PyTorch( entry_point='your_training_script.py', source_dir='path-to-requirements-file', # Optional. Add this if need to install additional packages. instance_count=instance_count, instance_type=instance_type, framework_version='1.13.1', py_version='py3', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), distribution ={'pytorchxla' : { 'enabled': True }}, disable_profiler=True, debugger_hook_config=False ) pytorch_estimator.fit() ``` **sugerencia** Para preparar el script de entrenamiento, consulte [PyTorch](training-compiler-pytorch-models.md) ------ #### [ Transformers v4.21 with PyTorch v1.11 ] Para la PyTorch versión 1.11 y versiones posteriores, SageMaker Training Compiler está disponible para el entrenamiento distribuido con la `pytorch_xla` opción especificada en el parámetro. `distribution` ``` from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig # choose an instance type, specify the number of instances you want to use, # and set the num_gpus variable the number of GPUs per instance. instance_count=1 instance_type='ml.p3.8xlarge' num_gpus=4 # the original max batch size that can fit to GPU memory without compiler batch_size_native=16 learning_rate_native=float('5e-5') # an updated max batch size that can fit to GPU memory with compiler batch_size=26 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count hyperparameters={ "n_gpus": num_gpus, "batch_size": batch_size, "learning_rate": learning_rate } pytorch_huggingface_estimator=HuggingFace( entry_point='your_training_script.py', instance_count=instance_count, instance_type=instance_type, transformers_version='4.21.1', pytorch_version='1.11.0', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), distribution ={'pytorchxla' : { 'enabled': True }}, disable_profiler=True, debugger_hook_config=False ) pytorch_huggingface_estimator.fit() ``` **sugerencia** Para preparar su script de entrenamiento, consulte las siguientes páginas. [Para entrenamiento distribuido](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)de un PyTorch modelo que utiliza la API Trainer de Hugging Face [Transformers](https://huggingface.co/transformers/main_classes/trainer.html) [Para entrenamiento distribuido](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)de un PyTorch modelo sin la API Trainer de Hugging Face [Transformers](https://huggingface.co/transformers/main_classes/trainer.html) ------ #### [ Transformers v4.17 with PyTorch v1.10.2 and before ] Para la versión compatible de la PyTorch v1.10.2 y anteriores, SageMaker Training Compiler requiere un mecanismo alternativo para lanzar un trabajo de formación distribuido. Para llevar a cabo un entrenamiento distribuido, SageMaker Training Compiler requiere que pases un guion de inicio de entrenamiento distribuido mediante SageMaker IA al `entry_point` argumento y que pases tu guion de entrenamiento al argumento. `hyperparameters` El siguiente ejemplo de código muestra cómo configurar un estimador SageMaker AI Hugging Face aplicando los cambios necesarios. ``` from sagemaker.huggingface import HuggingFace, TrainingCompilerConfig # choose an instance type, specify the number of instances you want to use, # and set the num_gpus variable the number of GPUs per instance. instance_count=1 instance_type='ml.p3.8xlarge' num_gpus=4 # the original max batch size that can fit to GPU memory without compiler batch_size_native=16 learning_rate_native=float('5e-5') # an updated max batch size that can fit to GPU memory with compiler batch_size=26 # update learning rate learning_rate=learning_rate_native/batch_size_native*batch_size*num_gpus*instance_count training_script="your_training_script.py" hyperparameters={ "n_gpus": num_gpus, "batch_size": batch_size, "learning_rate": learning_rate, "training_script": training_script # Specify the file name of your training script. } pytorch_huggingface_estimator=HuggingFace( entry_point='distributed_training_launcher.py', # Specify the distributed training launcher script. instance_count=instance_count, instance_type=instance_type, transformers_version='4.17.0', pytorch_version='1.10.2', hyperparameters=hyperparameters, compiler_config=TrainingCompilerConfig(), disable_profiler=True, debugger_hook_config=False ) pytorch_huggingface_estimator.fit() ``` El script del lanzador debe tener el aspecto siguiente: Encapsula el script de entrenamiento y configura el entorno de entrenamiento distribuido en función del tamaño de la instancia de entrenamiento que elija. ``` # distributed_training_launcher.py #!/bin/python import subprocess import sys if __name__ == "__main__": arguments_command = " ".join([arg for arg in sys.argv[1:]]) """ The following line takes care of setting up an inter-node communication as well as managing intra-node workers for each GPU. """ subprocess.check_call("python -m torch_xla.distributed.sm_dist " + arguments_command, shell=True) ``` **sugerencia** Para preparar su script de entrenamiento, consulte las siguientes páginas. [Para entrenamiento distribuido](training-compiler-pytorch-models.md#training-compiler-pytorch-models-transformers-trainer-distributed)de un PyTorch modelo que utiliza la API Trainer de Hugging Face [Transformers](https://huggingface.co/transformers/main_classes/trainer.html) [Para entrenamiento distribuido](training-compiler-pytorch-models.md#training-compiler-pytorch-models-non-trainer-distributed)de un PyTorch modelo sin la API Trainer de Hugging Face [Transformers](https://huggingface.co/transformers/main_classes/trainer.html) **sugerencia** Para encontrar end-to-end ejemplos, consulte los siguientes cuadernos: [Compila y entrena el GPT2 modelo mediante la API Transformers Trainer con el SST2 conjunto de datos para el entrenamiento con un solo nodo y varias GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_single_node/language-modeling-multi-gpu-single-node.html) [Compila y entrena el GPT2 modelo mediante la API Transformers Trainer y el SST2 conjunto de datos para el entrenamiento con varios nodos y varias GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_multiple_node/language-modeling-multi-gpu-multi-node.html) ------ La siguiente lista es el conjunto mínimo de parámetros necesarios para ejecutar un trabajo de SageMaker formación con el compilador. **nota** Cuando utilices el estimador SageMaker AI Hugging Face, debes especificar `transformers_version` los parámetros, `pytorch_version``hyperparameters`, `compiler_config` y para SageMaker habilitar Training Compiler. No puede utilizar `image_uri` para especificar manualmente los contenedores de aprendizaje profundo integrados en el Compilador de entrenamiento que aparecen en [Marcos admitidos](training-compiler-support.md#training-compiler-supported-frameworks). + `entry_point` (str): obligatorio. Especifique el nombre de archivo de su script de entrenamiento. **nota** Para ejecutar un entrenamiento distribuido con SageMaker Training Compiler y versiones anteriores, especifique PyTorch el nombre de archivo de un script de inicio para este parámetro. El script de inicio debe estar preparado para encapsular el script de entrenamiento y configurar el entorno de entrenamiento distribuido. Para obtener más información, consulte los ejemplos de cuadernos siguientes: [Compila y entrena el GPT2 modelo mediante la API Transformers Trainer y el conjunto de datos para el entrenamiento con un solo nodo y varias SST2 GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_single_node/language-modeling-multi-gpu-single-node.html) [Compila y entrena el GPT2 modelo mediante la API Transformers Trainer y el SST2 conjunto de datos para el entrenamiento con varios nodos y varias GPU](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-training-compiler/huggingface/pytorch_multiple_gpu_multiple_node/language-modeling-multi-gpu-multi-node.html) + `source_dir`(str): opcional. Añada esto si necesita instalar paquetes adicionales. Para instalar paquetes, debe preparar un archivo `requirements.txt` en este directorio. + `instance_count` (int): obligatorio. Especifique el número de instancias. + `instance_type` (str): obligatorio. Especifique el tipo de instancia. + `transformers_version`(str) — Necesario solo cuando se utiliza el SageMaker estimador AI Hugging Face. Especifique la versión de la biblioteca Hugging Face Transformers compatible con SageMaker Training Compiler. Para buscar las versiones disponibles, consulte [Marcos admitidos](training-compiler-support.md#training-compiler-supported-frameworks). + `framework_version` or `pytorch_version` (str): obligatorio. Especifique la PyTorch versión compatible con Training Compiler SageMaker . Para buscar las versiones disponibles, consulte [Marcos admitidos](training-compiler-support.md#training-compiler-supported-frameworks). **nota** Cuando utilices el estimador SageMaker AI Hugging Face, debes especificar tanto como. `transformers_version` `pytorch_version` + `hyperparameters` (dict): opcional. Especifique los hiperparámetros para el trabajo de entrenamiento, como `n_gpus`, `batch_size` y `learning_rate`. Cuando actives SageMaker Training Compiler, prueba con lotes más grandes y ajusta la tasa de aprendizaje en consecuencia. Para encontrar casos prácticos sobre el uso del compilador y los tamaños de lote ajustados para mejorar la velocidad de entrenamiento, consulte [Modelos probados](training-compiler-support.md#training-compiler-tested-models) y [SageMaker Ejemplos de cuadernos y blogs de Training Compiler](training-compiler-examples-and-blogs.md). **nota** Para ejecutar una formación distribuida con SageMaker Training Compiler y la PyTorch versión 1.10.2 y versiones anteriores, debe añadir un parámetro adicional para especificar el guion de formación`"training_script"`, tal y como se muestra en el ejemplo de código anterior. + `compiler_config`(TrainingCompilerConfig objeto): necesario para activar SageMaker Training Compiler. Incluya este parámetro para activar SageMaker Training Compiler. A continuación se incluyen los parámetros para la clase `TrainingCompilerConfig`. + `enabled` (bool): opcional. Especifique `True` o `False` active o desactive SageMaker Training Compiler. El valor predeterminado es `True`. + `debug` (bool): opcional. Para recibir registros de entrenamiento más detallados de sus trabajos de entrenamiento acelerados por el compilador, cámbielo a `True`. Sin embargo, el registro adicional podría añadir una sobrecarga y ralentizar el trabajo de entrenamiento compilado. El valor predeterminado es `False`. + `distribution` (dict): opcional. Para ejecutar un trabajo de formación distribuido con SageMaker Training Compiler, añada. `distribution = { 'pytorchxla' : { 'enabled': True }}` **aviso** Si activas SageMaker Debugger, esto podría afectar al rendimiento de SageMaker Training Compiler. Te recomendamos que desactives Debugger cuando ejecutes SageMaker Training Compiler para asegurarte de que esto no repercuta en el rendimiento. Para obtener más información, consulte [Consideraciones](training-compiler-tips-pitfalls.md#training-compiler-tips-pitfalls-considerations). Para desactivar las funcionalidades del Depurador, añada los dos argumentos siguientes al estimador: ``` disable_profiler=True, debugger_hook_config=False ``` Si el trabajo de entrenamiento con el compilador se ha iniciado correctamente, recibirá los siguientes registros durante la fase de inicialización del trabajo: + Con `TrainingCompilerConfig(debug=False)` ``` Found configuration for Training Compiler Configuring SM Training Compiler... ``` + Con `TrainingCompilerConfig(debug=True)` ``` Found configuration for Training Compiler Configuring SM Training Compiler... Training Compiler set to debug mode ``` ## Uso de la operación de la API de SageMaker IA `CreateTrainingJob` SageMaker Las opciones de configuración del compilador de entrenamiento deben especificarse mediante el `HyperParameters` campo `AlgorithmSpecification` y de la sintaxis de la solicitud para la operación de la [`CreateTrainingJob`API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). ``` "AlgorithmSpecification": { "TrainingImage": "" }, "HyperParameters": { "sagemaker_training_compiler_enabled": "true", "sagemaker_training_compiler_debug_mode": "false", "sagemaker_pytorch_xla_multi_worker_enabled": "false" // set to "true" for distributed training } ``` Para ver una lista completa de imágenes de contenedores de aprendizaje profundo URIs que tienen implementado SageMaker Training Compiler, consulte. [Marcos admitidos](training-compiler-support.md#training-compiler-supported-frameworks)