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à.

# Esegui il tuo codice locale come processo SageMaker di formazione
<a name="train-remote-decorator"></a>

Puoi eseguire il codice Python locale di machine learning (ML) come un grande processo di formazione SageMaker Amazon a nodo singolo o come più processi paralleli. È possibile farlo annotando il codice con un decoratore @remote, come mostrato nel seguente esempio di codice. L'addestramento[ distribuito](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-training.html) (tra più istanze) non è supportato con le funzioni remote.

```
@remote(**settings)
def divide(x, y):
    return x / y
```

L'SDK SageMaker Python tradurrà automaticamente l'ambiente di lavoro esistente e qualsiasi codice di elaborazione dati e set di dati associati in un processo di formazione che viene eseguito sulla piattaforma di SageMaker formazione. SageMaker È inoltre possibile attivare una funzionalità di cache persistente, che ridurrà ulteriormente la latenza di avvio del processo memorizzando nella cache i pacchetti di dipendenze precedentemente scaricati. Questa riduzione della latenza del lavoro è maggiore della riduzione della latenza derivante dall'utilizzo SageMaker dei soli pool caldi gestiti dall'IA. Per ulteriori informazioni, consulta [Utilizzo della cache persistente](train-warm-pools.md#train-warm-pools-persistent-cache).

**Nota**  
I processi di addestramento distribuiti non sono supportati dalle funzioni remote.

Nelle sezioni seguenti si mostra come annotare il codice ML locale con un decoratore @remote e personalizzare l'esperienza in base al caso d'uso. Ciò include la personalizzazione dell'ambiente e l'integrazione con Experiments. SageMaker 

**Topics**
+ [Configurare l'ambiente](#train-remote-decorator-env)
+ [Invocare una funzione remota](train-remote-decorator-invocation.md)
+ [File di configurazione](train-remote-decorator-config.md)
+ [Personalizzazione dell'ambiente di runtime](train-remote-decorator-customize.md)
+ [Compatibilità dell'immagine del container](train-remote-decorator-container.md)
+ [Registrazione di parametri e metriche con Amazon Experiments SageMaker](train-remote-decorator-experiments.md)
+ [Utilizzo del codice modulare con il decoratore @remote](train-remote-decorator-modular.md)
+ [Repository privato per le dipendenze di runtime](train-remote-decorator-private.md)
+ [Notebook di esempio](train-remote-decorator-examples.md)

## Configurare l'ambiente
<a name="train-remote-decorator-env"></a>

Seleziona una delle seguenti tre opzioni per configurare il tuo ambiente.

### Esegui il codice da Amazon SageMaker Studio Classic
<a name="train-remote-decorator-env-studio"></a>

Puoi annotare ed eseguire il codice ML locale da SageMaker Studio Classic creando un SageMaker Notebook e allegando qualsiasi immagine disponibile nell'immagine di SageMaker Studio Classic. Le seguenti istruzioni ti aiutano a creare un SageMaker Notebook, installare l'SDK SageMaker Python e annotare il codice con il decoratore.

1. Crea un SageMaker taccuino e allega un'immagine in SageMaker Studio Classic come segue:

   1. Segui le istruzioni in [Launch Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html) nella *Amazon SageMaker AI Developer Guide*.

   1. Seleziona **Studio** dal riquadro di navigazione a sinistra. Si apre una nuova finestra.

   1. Nella finestra di dialogo **Inizia**, seleziona un profilo utente dalla freccia rivolta verso il basso. Si apre una nuova finestra.

   1. Seleziona **Apri Studio Classic**.

   1. Seleziona **Apri utilità di avvio** dall'area di lavoro principale. Viene aperta una nuova pagina.

   1. Seleziona **Crea notebook** dall'area di lavoro principale.

   1. Seleziona **Base Python 3.0** dalla freccia rivolta verso il basso accanto a **Immagine** nella finestra di dialogo **Cambia ambiente**. 

      Il decoratore @remote rileva automaticamente l'immagine allegata al notebook SageMaker Studio Classic e la utilizza per eseguire il processo di SageMaker formazione. Se `image_uri` viene specificato come argomento nel decoratore o nel file di configurazione, verrà utilizzato il valore specificato in `image_uri` al posto dell'immagine rilevata.

      Per ulteriori informazioni su come creare un notebook in SageMaker Studio Classic, consulta la sezione **Creare un notebook dal menu File** in [Creare o aprire un notebook Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-create-open.html#notebooks-create-file-menu).

      Per un elenco delle immagini disponibili, consulta [Supported Docker images](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-container.html).

1. Installa l' SageMaker SDK Python.

   Per annotare il codice con la funzione @remote all'interno di uno SageMaker Studio Classic Notebook, devi avere installato SageMaker Python SDK. Installa SageMaker Python SDK, come mostrato nel seguente esempio di codice.

   ```
   !pip install sagemaker
   ```

1. Usa @remote decorator per eseguire funzioni in un SageMaker processo di formazione.

   Per eseguire il codice ML locale, crea prima un file di dipendenze per indicare all' SageMaker IA dove localizzare il codice locale. A tale scopo, procedi nel modo seguente:

   1. **Dall'area di lavoro principale di SageMaker Studio Classic Launcher, in **Utilità e file, scegli File** di testo.** Si apre una nuova scheda con un file di testo denominato `untitled.txt.` 

      Per ulteriori informazioni sull'interfaccia utente (UI) di SageMaker Studio Classic, consulta [Panoramica dell'interfaccia utente di Amazon SageMaker Studio Classic](https://docs.aws.amazon.com//sagemaker/latest/dg/studio-ui.html).

   1. Rinomina `untitled.txt ` in `requirements.txt`.

   1. Aggiungi tutte le dipendenze richieste per il codice insieme alla libreria SageMaker AI a`requirements.txt`. 

      Un esempio di codice minimo `requirements.txt` per la funzione `divide` di esempio è illustrato nella sezione seguente, come segue.

      ```
      sagemaker
      ```

   1. Esegui il codice con il decoratore remoto trasmettendo il file delle dipendenze, come segue.

      ```
      from sagemaker.remote_function import remote
      
      @remote(instance_type="ml.m5.xlarge", dependencies='./requirements.txt')
      def divide(x, y):
          return x / y
      
      divide(2, 3.0)
      ```

      Per ulteriori esempi di codice, consulta il notebook di esempio [quick\_start.ipynb.](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb)

      **Se utilizzi già un notebook SageMaker Studio Classic e installi Python SDK come indicato in 2. Installa l'SDK SageMaker Python**, devi riavviare il kernel. Per ulteriori informazioni, consulta [Usa la barra degli strumenti di SageMaker Studio Classic Notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-menu.html) nella *Amazon SageMaker AI Developer Guide*.

### Esegui il codice da un SageMaker notebook Amazon
<a name="train-remote-decorator-env-notebook"></a>

Puoi annotare il codice ML locale da un'istanza di SageMaker notebook. Le seguenti istruzioni mostrano come creare un'istanza di notebook con un kernel personalizzato, installare SageMaker Python SDK e annotare il codice con il decoratore.

1. Crea un'istanza di notebook con un kernel `conda` personalizzato.

   Puoi annotare il tuo codice ML locale con un decoratore @remote da utilizzare all'interno di un lavoro di formazione. SageMaker Per prima cosa devi creare e personalizzare un'istanza di SageMaker notebook per usare un kernel con Python versione 3.7 o successiva, fino alla 3.10.x. A tale scopo, procedi nel modo seguente:

   1. Apri la console AI all'indirizzo. SageMaker [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)

   1. Nel pannello di navigazione a sinistra, scegli **Notebook** per ampliare le opzioni.

   1. Scegli **Istanze del notebook** dalle opzioni espanse.

   1. Scegli il pulsante **Crea istanza del notebook**. Si apre una nuova pagina.

   1. Per **Nome dell'istanza del notebook**, immetti un nome con un massimo di 63 caratteri e senza spazi. I caratteri validi sono: **A-Z**, **a-z**, **0-9** e **.****:****\+****=****@**** \_****%****-** (trattino).

   1. Nella finestra di dialogo **Impostazioni istanza del notebook**, espandi la freccia destra accanto a **Configurazione aggiuntiva**.

   1. In **Configurazione ciclo di vita (facoltativo)**, espandi la freccia rivolta verso il basso e seleziona **Crea una nuova configurazione del ciclo di vita**. Si apre una nuova finestra di dialogo.

   1. In **Nome** immetti un nome per l'impostazione di avvio.

   1. Nella finestra di dialogo **Script**, nella scheda **Avvia notebook**, sostituisci il contenuto esistente della casella di testo con lo script seguente.

      ```
      #!/bin/bash
      
      set -e
      
      sudo -u ec2-user -i <<'EOF'
      unset SUDO_UID
      WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda/
      source "$WORKING_DIR/miniconda/bin/activate"
      for env in $WORKING_DIR/miniconda/envs/*; do
          BASENAME=$(basename "$env")
          source activate "$BASENAME"
          python -m ipykernel install --user --name "$BASENAME" --display-name "Custom ($BASENAME)"
      done
      EOF
      
      echo "Restarting the Jupyter server.."
      # restart command is dependent on current running Amazon Linux and JupyterLab
      CURR_VERSION_AL=$(cat /etc/system-release)
      CURR_VERSION_JS=$(jupyter --version)
      
      if [[ $CURR_VERSION_JS == *$"jupyter_core     : 4.9.1"* ]] && [[ $CURR_VERSION_AL == *$" release 2018"* ]]; then
       sudo initctl restart jupyter-server --no-wait
      else
       sudo systemctl --no-block restart jupyter-server.service
      fi
      ```

   1. Nella finestra di dialogo **Script**, nella scheda **Crea notebook**, sostituisci il contenuto esistente della casella di testo con lo script seguente.

      ```
      #!/bin/bash
      
      set -e
      
      sudo -u ec2-user -i <<'EOF'
      unset SUDO_UID
      # Install a separate conda installation via Miniconda
      WORKING_DIR=/home/ec2-user/SageMaker/custom-miniconda
      mkdir -p "$WORKING_DIR"
      wget https://repo.anaconda.com/miniconda/Miniconda3-4.6.14-Linux-x86_64.sh -O "$WORKING_DIR/miniconda.sh"
      bash "$WORKING_DIR/miniconda.sh" -b -u -p "$WORKING_DIR/miniconda" 
      rm -rf "$WORKING_DIR/miniconda.sh"
      # Create a custom conda environment
      source "$WORKING_DIR/miniconda/bin/activate"
      KERNEL_NAME="custom_python310"
      PYTHON="3.10"
      conda create --yes --name "$KERNEL_NAME" python="$PYTHON" pip
      conda activate "$KERNEL_NAME"
      pip install --quiet ipykernel
      # Customize these lines as necessary to install the required packages
      EOF
      ```

   1. Scegli il pulsante **Crea configurazione** in basso a destra nella finestra.

   1. Scegli il pulsante **Crea istanza del notebook** in basso a destra nella finestra.

   1. Attendi che **lo stato dell'istanza del** notebook passi da **In sospeso** a **InService**.

1. Creazione di un notebook Jupyter nell'istanza del notebook.

   Le seguenti istruzioni mostrano come creare un notebook Jupyter usando Python 3.10 nell'istanza appena creata. SageMaker 

   1. Dopo aver impostato lo **stato dell'istanza del** notebook del passaggio precedente, procedi come segue: **InService** 

      1. Seleziona **Apri Jupyter** in **Azioni** nella riga contenente il nome dell'istanza del notebook **Nome** appena creata. Si apre un nuovo server Jupyter.

   1. Nel server Jupyter, seleziona **Nuovo** dal menu in alto a destra. 

   1. Dalla freccia rivolta verso il basso, seleziona **conda\_custom\_python310**. Così facendo, viene creato un nuovo notebook Jupyter che utilizza un kernel Python 3.10. Questo nuovo notebook Jupyter può ora essere usato in modo simile a un notebook Jupyter locale. 

1. Installa l' SageMaker SDK Python.

   Dopo l'esecuzione dell'ambiente virtuale, installa SageMaker Python SDK utilizzando il seguente esempio di codice.

   ```
   !pip install sagemaker
   ```

1. Usa un decoratore @remote per eseguire funzioni in un SageMaker processo di formazione.

   Quando annotate il codice ML locale con un decoratore @remote all'interno del SageMaker taccuino, la SageMaker formazione interpreterà automaticamente la funzione del codice e lo eseguirà come un SageMaker lavoro di formazione. Configura il notebook effettuando le seguenti operazioni:

   1. Seleziona il nome del kernel nel menu del notebook dall'istanza del SageMaker notebook che hai creato nel passaggio 1, **Crea un'istanza SageMaker Notebook con un** kernel personalizzato.

      Per ulteriori informazioni, consulta [Change an Image or a Kernel](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-run-and-manage-change-image.html). 

   1. Dalla freccia rivolta verso il basso, scegli un kernel `conda` personalizzato che utilizza una versione di Python 3.7 o superiore. 

      Ad esempio, selezionando `conda_custom_python310`, viene scelto il kernel per Python 3.10.

   1. Scegli **Seleziona**.

   1. Attendi che lo stato del kernel venga visualizzato come inattivo, a indicare che il kernel è stato avviato.

   1. Nella pagina iniziale del server Jupyter, seleziona **Nuovo** dal menu in alto a destra.

   1. Accanto alla freccia rivolta verso il basso, seleziona **File di testo**. Così facendo, viene creato un nuovo file di testo denominato `untitled.txt.`

   1. Rinomina `untitled.txt` in `requirements.txt` e aggiungi le eventuali dipendenze richieste per il codice insieme a `sagemaker`.

   1. Esegui il codice con il decoratore remoto trasmettendo il file delle dipendenze, come mostrato di seguito.

      ```
      from sagemaker.remote_function import remote
      
      @remote(instance_type="{{ml.m5.xlarge}}", dependencies='./requirements.txt')
      def divide(x, y):
          return x / y
      
      divide(2, 3.0)
      ```

      Per ulteriori esempi di codice, consulta il notebook di esempio [quick\_start.ipynb.](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb)

### Esecuzione del codice dall'interno dell'IDE locale
<a name="train-remote-decorator-env-ide"></a>

È possibile annotare il codice ML locale con un decoratore @remote all'interno dell'IDE locale preferito. Le fasi seguenti mostrano i prerequisiti necessari, come installare Python SDK e come annotare il codice con il decoratore @remote.

1. Installa i prerequisiti impostando AWS Command Line Interface (AWS CLI) e creando un ruolo, come segue:
   + Effettua l'onboarding su un dominio SageMaker AI seguendo le istruzioni nella sezione **AWS CLI Prerequisiti di Configurazione dei prerequisiti** [di Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html#gs-cli-prereq).
   + [Crea un ruolo IAM seguendo la sezione **Create execution role** di SageMaker AI Roles.](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)

1. Crea un ambiente virtuale utilizzando PyCharm o `conda` e utilizzando Python versione 3.7 o successiva, fino alla 3.10.x.
   + Configura un ambiente virtuale utilizzando quanto segue: PyCharm 

     1. Seleziona **File** dal menu principale.

     1. Scegli **Nuovo progetto**.

     1. Scegli **Conda** dalla freccia rivolta verso il basso in **Nuovo ambiente utilizzando**.

     1. Nel campo relativo alla **versione Python**, usa la freccia rivolta verso il basso per selezionare una versione di Python 3.7 o superiore. È possibile andare fino alla versione 3.10.x dall'elenco.  
![Nuovo ambiente Python selezionato come Conda, con la versione Python selezionata alla 3.10.](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/training-pycharm-ide.png)
   + Se è stato installato Anaconda, è possibile configurare un ambiente virtuale usando `conda`, come segue:
     + Apri un'interfaccia di terminale del prompt di Anaconda.
     + Crea e attiva un nuovo ambiente `conda` usando la versione Python 3.7 o successiva, fino alla versione 3.10x. L'esempio di codice seguente mostra come creare un ambiente `conda` utilizzando Python versione 3.10.

       ```
       conda create -n {{sagemaker_jobs_quick_start}} python=3.10 pip
       conda activate {{sagemaker_jobs_quick_start}}
       ```

1. Installa l' SageMaker SDK Python.

   Per impacchettare il codice dall'IDE preferito è necessario disporre di un ambiente virtuale configurato usando Python 3.7 o le versioni successive, fino alla 3.10x. È inoltre necessaria un'immagine del container compatibile. Installa SageMaker Python SDK usando il seguente esempio di codice.

   ```
   pip install sagemaker
   ```

1. Racchiudi il codice all'interno del decoratore @remote. L'SDK SageMaker Python interpreterà automaticamente la funzione del codice e la eseguirà come processo di SageMaker formazione. I seguenti esempi di codice mostrano come importare le librerie necessarie, impostare una SageMaker sessione e annotare una funzione con il decoratore @remote.

   È possibile eseguire il codice fornendo direttamente le dipendenze necessarie o utilizzando le dipendenze dall'ambiente `conda` attivo.
   + Per fornire direttamente le dipendenze, procedi come segue:
     + Crea un file `requirements.txt` nella directory di lavoro in cui risiede il codice.
     + Aggiungi tutte le dipendenze richieste per il codice insieme alla libreria. SageMaker La sezione seguente fornisce un esempio minimo di codice per `requirements.txt` per la funzione di esempio `divide`.

       ```
       sagemaker
       ```
     + Esegui il codice con il decoratore @remote passando il file delle dipendenze. Nel seguente esempio di codice, sostituisci `The IAM role name` con un ruolo AWS Identity and Access Management (IAM) l'ARN che desideri utilizzare SageMaker per eseguire il processo.

       ```
       import boto3
       import sagemaker
       from sagemaker.remote_function import remote
       
       sm_session = sagemaker.Session(boto_session=boto3.session.Session(region_name="{{us-west-2}}"))
       settings = dict(
           sagemaker_session=sm_session,
           role={{<The IAM role name>}},
           instance_type="{{ml.m5.xlarge}}",
           dependencies='./requirements.txt'
       )
       
       @remote(**settings)
       def divide(x, y):
           return x / y
       
       
       if __name__ == "__main__":
           print(divide(2, 3.0))
       ```
   + Per utilizzare le dipendenze dall'ambiente `conda` attivo, utilizza il valore `auto_capture` del parametro `dependencies`, come illustrato di seguito.

     ```
     import boto3
     import sagemaker
     from sagemaker.remote_function import remote
     
     sm_session = sagemaker.Session(boto_session=boto3.session.Session(region_name="{{us-west-2}}"))
     settings = dict(
         sagemaker_session=sm_session,
         role={{<The IAM role name>}},
         instance_type="{{ml.m5.xlarge}}",
         dependencies="auto_capture"
     )
     
     @remote(**settings)
     def divide(x, y):
         return x / y
     
     
     if __name__ == "__main__":
         print(divide(2, 3.0))
     ```
**Nota**  
Puoi anche implementare il codice precedente all'interno di un notebook Jupyter. PyCharm Professional Edition supporta Jupyter in modo nativo. Per ulteriori informazioni, consulta il supporto per notebook [Jupyter](https://www.jetbrains.com/help/pycharm/ipython-notebook-support.html) nella documentazione. PyCharm