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 SageMaker attività di formazione
Puoi eseguire il tuo codice Python di machine learning (ML) locale come un grande processo di SageMaker formazione Amazon a nodo singolo o come più lavori 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 e set di dati di elaborazione dati associato in un processo di formazione 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 dei processi è superiore alla riduzione della latenza derivante dall'utilizzo SageMaker dei soli warm pool gestiti dall'intelligenza artificiale. 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
Seleziona una delle seguenti tre opzioni per configurare il tuo ambiente.
### Esegui il codice da Amazon Studio Classic SageMaker
Puoi annotare ed eseguire il codice ML locale da SageMaker Studio Classic creando un SageMaker Notebook e allegando qualsiasi immagine disponibile sull'immagine di SageMaker Studio Classic. Le seguenti istruzioni ti aiutano a creare un SageMaker Notebook, installare SageMaker Python SDK 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 taccuino 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'SDK SageMaker Python.
Per annotare il codice con la funzione @remote all'interno di uno SageMaker Studio Classic Notebook, è necessario che SageMaker Python SDK sia installato. Installa l'SDK SageMaker Python, come mostrato nel seguente esempio di codice.
```
!pip install sagemaker
```
1. Usa @remote decorator per eseguire funzioni in un SageMaker lavoro 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 la 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 stai già utilizzando 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 [ Use the SageMaker Studio Classic Notebook Toolbar ](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-menu.html) nella * Amazon SageMaker AI Developer Guide. *
### Esegui il codice da un notebook Amazon SageMaker
Puoi annotare il tuo codice ML locale da un'istanza del SageMaker notebook. Le seguenti istruzioni mostrano come creare un'istanza del 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 Innanzitutto è necessario creare e personalizzare un'istanza di SageMaker notebook per utilizzare 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' SageMaker indirizzo. [ 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. Caratteri validi: ** 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, effettuate le seguenti operazioni: ** 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'SDK SageMaker 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 lavoro di formazione.
Quando si annota il codice ML locale con un decoratore @remote all'interno del SageMaker notebook, 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. Selezionate il nome del kernel nel menu del notebook dall'istanza del SageMaker notebook creata nel passaggio 1, ** Create a SageMaker Notebook instance with a custom kernel. **
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
È 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 in un dominio SageMaker AI seguendo le istruzioni nella ** sezione Prerequisiti di [Configurazione dei AWS CLI 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 ** Crea ruolo di esecuzione di [ SageMaker AI Roles. ](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)
1. Crea un ambiente virtuale usando uno PyCharm o `conda` e usando Python versione 3.7 o successiva, fino alla 3.10.x.
+ Configura un ambiente virtuale utilizzando PyCharm quanto segue:
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.
+ 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'SDK SageMaker 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 lo eseguirà come lavoro di formazione. SageMaker 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) ARN che desideri utilizzare SageMaker per eseguire il tuo lavoro.
```
import boto3
from sagemaker.core.helper.session_helper import Session
from sagemaker.remote_function import remote
sm_session = Session(boto_session=boto3.session.Session(region_name="{{us-west-2}}"))
settings = dict(
sagemaker_session=sm_session,
role={{}},
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
from sagemaker.core.helper.session_helper import Session
from sagemaker.remote_function import remote
sm_session = Session(boto_session=boto3.session.Session(region_name="{{us-west-2}}"))
settings = dict(
sagemaker_session=sm_session,
role={{}},
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 La Professional Edition supporta Jupyter in modo nativo. Per ulteriori indicazioni, consulta il supporto per notebook [ Jupyter nella documentazione. ](https://www.jetbrains.com/help/pycharm/ipython-notebook-support.html) PyCharm