Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Prepara ed esegui un processo di formazione con Profiler SageMaker
<a name="profiler-prepare"></a>

La configurazione per l'esecuzione di un processo di formazione con SageMaker Profiler prevede due passaggi: adattare lo script di formazione e configurare il SageMaker training job launcher.

**Topics**
+ [Passaggio 1: adattare lo script di formazione utilizzando i moduli SageMaker Profiler Python](#profiler-prepare-training-script)
+ [Fase 2: Creare uno stimatore del framework SageMaker AI e attivare Profiler SageMaker](#profiler-profilerconfig)
+ [(Facoltativo) Installa il pacchetto SageMaker Profiler Python](#profiler-install-python-package)

## Passaggio 1: adattare lo script di formazione utilizzando i moduli SageMaker Profiler Python
<a name="profiler-prepare-training-script"></a>

Per iniziare a registrare le esecuzioni del kernel GPUs mentre il processo di formazione è in esecuzione, modificate lo script di addestramento utilizzando i moduli Profiler Python. SageMaker Importa la libreria e aggiungi i metodi `start_profiling()` e `stop_profiling()` per definire l’inizio e la fine della profilazione. È inoltre possibile utilizzare annotazioni personalizzate opzionali per aggiungere evidenziatori nello script di addestramento per visualizzare le attività hardware durante particolari operazioni in ogni fase.

Nota che gli annotatori estraggono le operazioni da. GPUs Per le operazioni di profilatura in CPUs, non è necessario aggiungere annotazioni aggiuntive. La profilazione della CPU viene attivata anche quando specifichi la configurazione di profilazione, con la quale ti eserciterai in [Fase 2: Creare uno stimatore del framework SageMaker AI e attivare Profiler SageMaker](#profiler-profilerconfig).

**Nota**  
La profilazione di un intero job di addestramento non è l’uso più efficiente delle risorse. Consigliamo di profilare al massimo 300 fasi di un job di addestramento.

**Importante**  
La versione delle [14 dicembre 2023](profiler-release-notes.md#profiler-release-notes-20231214) contiene una modifica sostanziale. Il nome del pacchetto SageMaker Profiler Python viene modificato `smppy` da a. `smprof` Ciò è efficace in [SageMaker AI Framework Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) per la versione TensorFlow 2.12 e successive.  
Se utilizzi una delle versioni precedenti di [SageMaker AI Framework Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) come la TensorFlow v2.11.0, il pacchetto Profiler SageMaker Python è ancora disponibile come. `smppy` Se non siete sicuri della versione o del nome del pacchetto da utilizzare, sostituite l'istruzione import del pacchetto SageMaker Profiler con il seguente frammento di codice.  

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

**Approccio 1.** Utilizza il gestore di contesto `smprof.annotate` per annotare funzioni complete

Con il gestore di contesto `smprof.annotate()` puoi eseguire il wrapping di funzioni complete. Questo wrapper è consigliato se desideri creare profili per funzioni anziché per righe di codice. Lo script di esempio seguente mostra come implementare il gestore di contesto per eseguire il wrapping del ciclo di addestramento e delle funzioni complete in ogni iterazione.

```
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()
```

**Approccio 2.** Utilizza `smprof.annotation_begin()` e `smprof.annotation_end()` per annotare una riga di codice specifica nelle funzioni

Inoltre, puoi definire annotazioni per profilare righe di codice specifiche. È possibile impostare il punto di inizio e il punto di fine esatti della profilazione a livello di singole righe di codice, non in base alle funzioni. Ad esempio, nello script seguente, `step_annotator` viene definito all’inizio di ogni iterazione e termina alla fine dell’iterazione. Nel frattempo, vengono definiti altri annotatori dettagliati per ciascuna operazione, i quali eseguono il wrapping delle operazioni di destinazione durante ogni iterazione.

```
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()
```

Dopo aver annotato e configurato i moduli di avvio del profiler, salvate lo script da inviare utilizzando un SageMaker training job launcher nel passaggio 2 successivo. L’utilità di avvio di esempio presuppone che lo script di addestramento sia denominato `train_with_profiler_demo.py`.

## Fase 2: Creare uno stimatore del framework SageMaker AI e attivare Profiler SageMaker
<a name="profiler-profilerconfig"></a>

La procedura seguente mostra come preparare uno stimatore del framework SageMaker AI per l'addestramento utilizzando SageMaker Python SDK.

1. Configura un oggetto `profiler_config` utilizzando i moduli `ProfilerConfig` e `Profiler` nel modo seguente.

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

   Di seguito è riportata la descrizione del modulo `Profiler` e il relativo argomento.
   +  `Profiler`: Il modulo per attivare SageMaker Profiler con il job di formazione.
     +  `cpu_profiling_duration`(int): specifica la durata in secondi per la profilazione. CPUs L’impostazione predefinita è 3600 secondi. 

1. Crea uno stimatore del framework SageMaker AI con l'`profiler_config`oggetto creato nel passaggio precedente. Il codice seguente mostra un esempio di creazione di uno PyTorch stimatore. Se volete creare uno TensorFlow stimatore, importate `sagemaker.tensorflow.TensorFlow` invece e specificate una delle [TensorFlowversioni](profiler-support.md#profiler-support-frameworks-tensorflow) supportate da SageMaker Profiler. Per ulteriori informazioni sui framework e i tipi di istanza supportati, consulta [SageMaker Immagini del framework AI preinstallate 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. Avvia il job di addestramento eseguendo il metodo `fit`. Con `wait=False`, puoi silenziare i log dei job di addestramento e lasciarli funzionare in background.

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

Durante l’esecuzione del job di addestramento o dopo il completamento del job, puoi passare all’argomento successivo in [Apri l'applicazione SageMaker Profiler UI](profiler-access-smprofiler-ui.md) e iniziare a esplorare e visualizzare i profili salvati.

Se desideri accedere direttamente ai dati del profilo salvati nel bucket Amazon S3, utilizza lo script seguente per recuperare l’URI 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)
)
```

## (Facoltativo) Installa il pacchetto SageMaker Profiler Python
<a name="profiler-install-python-package"></a>

Per utilizzare SageMaker Profiler su PyTorch immagini del TensorFlow framework non elencate o su un contenitore Docker personalizzato per la formazione, puoi installare SageMaker Profiler utilizzando uno dei. [SageMaker Immagini del framework AI preinstallate con Profiler SageMaker](profiler-support.md#profiler-support-frameworks) [SageMaker File binari del pacchetto Python di Profiler](profiler-support.md#profiler-python-package)

**Opzione 1: installa il pacchetto SageMaker Profiler durante l'avvio di un processo di formazione**

[Se desideri utilizzare SageMaker Profiler per lavori di formazione che utilizzano PyTorch TensorFlow immagini non elencate[SageMaker Immagini del framework AI preinstallate con Profiler SageMaker](profiler-support.md#profiler-support-frameworks), crea un `requirements.txt` file e posizionalo nel percorso specificato per il `source_dir` parametro dello stimatore del framework SageMaker AI nel passaggio 2.](#profiler-profilerconfig) Per ulteriori informazioni sulla configurazione di un `requirements.txt` file in generale, consulta [Uso di librerie di terze parti](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#using-third-party-libraries) nella documentazione di *SageMaker Python SDK*. Nel file `requirements.txt`, aggiungi uno dei percorsi dei bucket S3 per il [SageMaker File binari del pacchetto Python di Profiler](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}}
```

**Opzione 2: installa il pacchetto SageMaker Profiler nei tuoi contenitori Docker personalizzati**

Se utilizzi un container Docker personalizzato per l’addestramento, aggiungi uno dei [SageMaker File binari del pacchetto Python di Profiler](profiler-support.md#profiler-python-package) al tuo 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}}
```

Per indicazioni sulla gestione di un contenitore Docker personalizzato per la formazione sull' SageMaker intelligenza artificiale in generale, vedi [Adattamento del tuo](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) contenitore di formazione.