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.

# Prepara y ejecuta un trabajo de formación con SageMaker Profiler
<a name="profiler-prepare"></a>

La configuración para ejecutar un trabajo de formación con el SageMaker Profiler consta de dos pasos: adaptar el guion de formación y configurar el lanzador de tareas de SageMaker formación.

**Topics**
+ [Paso 1: Adapte su script de entrenamiento con los módulos SageMaker Profiler Python](#profiler-prepare-training-script)
+ [Paso 2: Cree un estimador del marco de SageMaker IA y active Profiler SageMaker](#profiler-profilerconfig)
+ [(Opcional) Instale el paquete SageMaker Profiler Python](#profiler-install-python-package)

## Paso 1: Adapte su script de entrenamiento con los módulos SageMaker Profiler Python
<a name="profiler-prepare-training-script"></a>

Para empezar a capturar las ejecuciones del núcleo GPUs mientras se ejecuta el trabajo de entrenamiento, modifique el script de entrenamiento mediante los módulos Python de SageMaker Profiler. Importe la biblioteca y añada los métodos `start_profiling()` y `stop_profiling()` para definir el principio y el final de la creación de perfiles. También puede utilizar anotaciones personalizadas opcionales para añadir marcadores en el script de entrenamiento a fin de visualizar las actividades del hardware durante determinadas operaciones de cada paso.

Tenga en cuenta que los anotadores extraen las operaciones de. GPUs Para realizar operaciones de creación de perfiles CPUs, no es necesario añadir ninguna anotación adicional. La creación de perfiles de CPU también se activa cuando especificas la configuración de creación de perfiles, con la que practicará en [Paso 2: Cree un estimador del marco de SageMaker IA y active Profiler SageMaker](#profiler-profilerconfig).

**nota**  
Elaborar un perfil de todo un trabajo de entrenamiento no es el uso más eficiente de los recursos. Recomendamos perfilar un máximo de 300 pasos de un trabajo de entrenamiento.

**importante**  
La versión en [14 de diciembre de 2023](profiler-release-notes.md#profiler-release-notes-20231214) implica un cambio importante. El nombre del paquete SageMaker Profiler Python se cambia de `smppy` a`smprof`. Esto es efectivo en los [contenedores de SageMaker AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) para la TensorFlow versión 2.12 y versiones posteriores.  
Si utiliza una de las versiones anteriores de los [contenedores de SageMaker AI Framework](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only), como la TensorFlow v2.11.0, el paquete Profiler SageMaker Python seguirá disponible como. `smppy` Si no está seguro de qué versión o del nombre del paquete debe utilizar, sustituya la declaración de importación del paquete SageMaker Profiler por el siguiente fragmento de código.  

```
try:
    import smprof 
except ImportError:
    # backward-compatability for TF 2.11 and PT 1.13.1 images
    import smppy as smprof
```

**Método 1.** Utilice el administrador de contexto `smprof.annotate` para anotar todas las funciones

El administrador de contextos de `smprof.annotate()` puede encapsular todas las funciones. Se recomienda utilizar este contenedor si desea crear perfiles por funciones en lugar de por líneas de código. El siguiente script de ejemplo muestra cómo implementar el administrador de contexto para encapsular el ciclo de entrenamiento y todas las funciones en cada iteración.

```
import smprof

SMProf = smprof.SMProfiler.instance()
config = smprof.Config()
config.profiler = {
    "EnableCuda": "1",
}
SMProf.configure(config)
SMProf.start_profiling()

for epoch in range(args.epochs):
    if world_size > 1:
        sampler.set_epoch(epoch)
    tstart = time.perf_counter()
    for i, data in enumerate(trainloader, 0):
        with smprof.annotate({{"step_"+str(i)}}):
            inputs, labels = data
            inputs = inputs.to("cuda", non_blocking=True)
            labels = labels.to("cuda", non_blocking=True)
    
            optimizer.zero_grad()
    
            with smprof.annotate({{"Forward"}}):
                outputs = net(inputs)
            with smprof.annotate({{"Loss"}}):
                loss = criterion(outputs, labels)
            with smprof.annotate({{"Backward"}}):
                loss.backward()
            with smprof.annotate({{"Optimizer"}}):
                optimizer.step()

SMProf.stop_profiling()
```

**Método 1.** Utilice `smprof.annotation_begin()` y `smprof.annotation_end()` anote una línea de código específica en funciones

También puede definir anotaciones para perfilar líneas de código específicas. Puede establecer el punto de inicio y el punto de conexión exactos de la creación de perfiles a nivel de líneas de código individuales, no mediante las funciones. Por ejemplo, en el siguiente script, el `step_annotator` se define el al principio de cada iteración y termina al final de la iteración. Mientras tanto, se definen otros anotadores detallados para cada operación y encapsulan las operaciones objetivo a lo largo de cada iteración.

```
import smprof

SMProf = smprof.SMProfiler.instance()
config = smprof.Config()
config.profiler = {
    "EnableCuda": "1",
}
SMProf.configure(config)
SMProf.start_profiling()

for epoch in range(args.epochs):
    if world_size > 1:
        sampler.set_epoch(epoch)
    tstart = time.perf_counter()
    for i, data in enumerate(trainloader, 0):
        step_annotator = smprof.annotation_begin({{"step_" + str(i)}})

        inputs, labels = data
        inputs = inputs.to("cuda", non_blocking=True)
        labels = labels.to("cuda", non_blocking=True)
        optimizer.zero_grad()

        forward_annotator = smprof.annotation_begin({{"Forward"}})
        outputs = net(inputs)
        smprof.annotation_end(forward_annotator)

        loss_annotator = smprof.annotation_begin({{"Loss"}})
        loss = criterion(outputs, labels)
        smprof.annotation_end(loss_annotator)

        backward_annotator = smprof.annotation_begin({{"Backward"}})
        loss.backward()
        smprof.annotation_end(backward_annotator)

        optimizer_annotator = smprof.annotation_begin({{"Optimizer"}})
        optimizer.step()
        smprof.annotation_end(optimizer_annotator)

        smprof.annotation_end(step_annotator)

SMProf.stop_profiling()
```

Tras anotar y configurar los módulos de iniciación del generador de perfiles, guarde el guion para enviarlo mediante un lanzador de tareas de SageMaker formación en el siguiente paso 2. En el ejemplo del lanzador se presupone que el script de entrenamiento se llama `train_with_profiler_demo.py`.

## Paso 2: Cree un estimador del marco de SageMaker IA y active Profiler SageMaker
<a name="profiler-profilerconfig"></a>

El siguiente procedimiento muestra cómo preparar un estimador del marco de SageMaker IA para el entrenamiento con el SDK de SageMaker Python.

1. Configure un objeto `profiler_config` mediante los módulos `ProfilerConfig` y `Profiler` de la siguiente manera.

   ```
   from sagemaker import ProfilerConfig, Profiler
   profiler_config = ProfilerConfig(
       profile_params = Profiler(cpu_profiling_duration=3600)
   )
   ```

   La siguiente es la descripción del módulo `Profiler` y su argumento.
   +  `Profiler`: El módulo para activar SageMaker Profiler con el trabajo de formación.
     +  `cpu_profiling_duration`(int): especifique la duración en segundos para activar la creación de perfiles. CPUs El valor predeterminado es de 3600 segundos. 

1. Cree un estimador del marco de SageMaker IA con el `profiler_config` objeto creado en el paso anterior. En el siguiente código se muestra un ejemplo de creación de un PyTorch estimador. Si desea crear un TensorFlow estimador, impórtelo `sagemaker.tensorflow.TensorFlow` en su lugar y especifique una de [TensorFlowlas versiones](profiler-support.md#profiler-support-frameworks-tensorflow) compatibles con Profiler. SageMaker Para obtener más información sobre los tipos de instancias admitidos, consulte [SageMaker Imágenes de AI Framework preinstaladas con Profiler SageMaker](profiler-support.md#profiler-support-frameworks).

   ```
   import sagemaker
   from sagemaker.pytorch import PyTorch
   
   estimator = PyTorch(
       framework_version="{{2.0.0}}",
       role=sagemaker.get_execution_role(),
       entry_point="{{train_with_profiler_demo.py}}", # your training job entry point
       source_dir={{source_dir}}, # source directory for your training script
       output_path={{output_path}},
       base_job_name="{{sagemaker-profiler-demo}}",
       hyperparameters={{hyperparameters}}, # if any
       instance_count={{1}}, # Recommended to test with < 8
       instance_type={{ml.p4d.24xlarge}},
       profiler_config={{profiler_config}}
   )
   ```

1. Inicie el trabajo de entrenamiento ejecutando el método `fit`. Con `wait=False`, puede silenciar los registros de los trabajos de entrenamiento y dejar que se ejecuten en segundo plano.

   ```
   estimator.fit(wait=False)
   ```

Mientras ejecuta el trabajo de entrenamiento o una vez finalizado el trabajo, puede pasar al tema siguiente en [Abre la aplicación de interfaz de SageMaker usuario Profiler](profiler-access-smprofiler-ui.md) y empezar a explorar y visualizar los perfiles guardados.

Si desea acceder directamente a los datos del perfil guardados en el bucket de Amazon S3, utilice el siguiente script para recuperar el URI de S3.

```
import os
# This is an ad-hoc function to get the S3 URI
# to where the profile output data is saved
def get_detailed_profiler_output_uri(estimator):
    config_name = None
    for processing in estimator.profiler_rule_configs:
        params = processing.get("RuleParameters", dict())
        rule = config_name = params.get("rule_to_invoke", "")
        if rule == "DetailedProfilerProcessing":
            config_name = processing.get("RuleConfigurationName")
            break
    return os.path.join(
        estimator.output_path, 
        estimator.latest_training_job.name, 
        "rule-output",
        config_name,
    )

print(
    f"Profiler output S3 bucket: ", 
    get_detailed_profiler_output_uri(estimator)
)
```

## (Opcional) Instale el paquete SageMaker Profiler Python
<a name="profiler-install-python-package"></a>

Para usar SageMaker Profiler en imágenes de TensorFlow marcos PyTorch o marcos que no figuran en [SageMaker Imágenes de AI Framework preinstaladas con Profiler SageMaker](profiler-support.md#profiler-support-frameworks) él o en su propio contenedor Docker personalizado con fines de formación, puede instalar SageMaker Profiler mediante uno de los. [SageMaker Archivos binarios del paquete Profiler Python](profiler-support.md#profiler-python-package)

**Opción 1: Instale el paquete SageMaker Profiler al iniciar un trabajo de formación**

[Si desea utilizar SageMaker Profiler para realizar tareas de formación con TensorFlow imágenes PyTorch o imágenes que no figuran en ellas[SageMaker Imágenes de AI Framework preinstaladas con Profiler SageMaker](profiler-support.md#profiler-support-frameworks), cree un `requirements.txt` archivo y ubíquelo en la ruta que especifique para el `source_dir` parámetro del estimador del marco de SageMaker IA en el paso 2.](#profiler-profilerconfig) Para obtener más información sobre la configuración de un `requirements.txt` archivo en general, consulte [Uso de bibliotecas de terceros](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#using-third-party-libraries) en la *documentación del SDK de SageMaker Python*. En el archivo `requirements.txt`, añada una de las rutas de bucket de S3 para los [SageMaker Archivos binarios del paquete Profiler Python](profiler-support.md#profiler-python-package).

```
# requirements.txt
https://smppy.s3.amazonaws.com/{{tensorflow/cu112/smprof-0.3.332-cp39-cp39-linux_x86_64.whl}}
```

**Opción 2: instale el paquete SageMaker Profiler en sus contenedores Docker personalizados**

Si usa un contenedor de Docker personalizado para entrenamiento, agregue uno de los [SageMaker Archivos binarios del paquete Profiler Python](profiler-support.md#profiler-python-package) a su Dockerfile.

```
# Install the smprof package version compatible with your CUDA version
RUN pip install https://smppy.s3.amazonaws.com/{{tensorflow/cu112/smprof-0.3.332-cp39-cp39-linux_x86_64.whl}}
```

Para obtener información sobre cómo ejecutar un contenedor Docker personalizado para el entrenamiento sobre SageMaker IA en general, consulta Cómo [adaptar tu propio](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) contenedor de entrenamiento.