Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Exécutez votre code local comme tâche SageMaker de formation
<a name="train-remote-decorator"></a>

Vous pouvez exécuter votre code Python local d'apprentissage automatique (ML) sous forme de tâche de SageMaker formation Amazon à nœud unique de grande taille ou de tâches parallèles multiples. Vous pouvez le faire en annotant votre code avec un décorateur @remote, comme illustré dans l’exemple de code suivant. [L’entraînement distribué](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-training.html) (sur plusieurs instances) n’est pas pris en charge par les fonctions distantes.

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

Le SDK SageMaker Python traduira automatiquement votre environnement d'espace de travail existant ainsi que tout code de traitement des données et ensembles de données associés en une tâche de SageMaker formation exécutée sur la plateforme de SageMaker formation. Vous pouvez également activer une fonctionnalité de cache permanent, qui réduira encore la latence de démarrage des tâches en mettant en cache les packages de dépendances précédemment téléchargés. Cette réduction de la latence des tâches est supérieure à celle résultant de l'utilisation de pools de chaleur gérés uniquement par l' SageMaker IA. Pour de plus amples informations, veuillez consulter [Utilisation du cache permanent](train-warm-pools.md#train-warm-pools-persistent-cache).

**Note**  
Les tâches d’entraînement distribuées ne sont pas prises en charge par les fonctions distantes.

Les sections suivantes montrent comment annoter votre code de machine learning local avec un décorateur @remote et adapter votre expérience à votre cas d’utilisation. Cela inclut la personnalisation de votre environnement et l'intégration à SageMaker Experiments.

**Topics**
+ [Configuration de votre environnement](#train-remote-decorator-env)
+ [Invoquer une fonction à distance](train-remote-decorator-invocation.md)
+ [Fichier de configuration](train-remote-decorator-config.md)
+ [Personnalisation de votre environnement d’exécution](train-remote-decorator-customize.md)
+ [Compatibilité avec les images du conteneur](train-remote-decorator-container.md)
+ [Paramètres et métriques de journalisation avec Amazon SageMaker Experiments](train-remote-decorator-experiments.md)
+ [Utilisation d’un code modulaire avec le décorateur @remote](train-remote-decorator-modular.md)
+ [Référentiel privé pour les dépendances d’exécution](train-remote-decorator-private.md)
+ [Exemples de blocs-notes](train-remote-decorator-examples.md)

## Configuration de votre environnement
<a name="train-remote-decorator-env"></a>

Choisissez l’une des trois options suivantes pour configurer votre environnement.

### Exécutez votre code depuis Amazon SageMaker Studio Classic
<a name="train-remote-decorator-env-studio"></a>

Vous pouvez annoter et exécuter votre code ML local à partir de SageMaker Studio Classic en créant un SageMaker bloc-notes et en joignant toute image disponible sur une image SageMaker Studio Classic. Les instructions suivantes vous aident à créer un SageMaker bloc-notes, à installer le SDK SageMaker Python et à annoter votre code avec le décorateur.

1. Créez un SageMaker bloc-notes et joignez une image dans SageMaker Studio Classic comme suit :

   1. Suivez les instructions de la [section Lancer Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-launch.html) dans le *guide du développeur Amazon SageMaker AI*.

   1. Sélectionnez **Studio** dans le panneau de navigation de gauche. Une nouvelle fenêtre s’ouvre.

   1. Dans la boîte de dialogue **Mise en route**, sélectionnez un profil utilisateur dans la flèche déroulante. Une nouvelle fenêtre s’ouvre.

   1. Sélectionnez **Ouvrir Studio Classic**.

   1. Sélectionnez **Ouvrir le lanceur** dans la zone de travail principale. Une nouvelle page s’ouvre.

   1. Sélectionnez **Créer un bloc-notes** dans la zone de travail principale.

   1. Sélectionnez **Base Python 3.0** dans la flèche déroulante à côté de **Image** dans la boîte de dialogue **Modifier l’environnement**. 

      Le décorateur @remote détecte automatiquement l'image jointe au bloc-notes SageMaker Studio Classic et l'utilise pour exécuter la tâche de SageMaker formation. Si `image_uri` est spécifiée en tant qu’argument dans le décorateur ou dans le fichier de configuration, la valeur spécifiée dans `image_uri` sera utilisée à la place de l’image détectée.

      Pour plus d'informations sur la création d'un bloc-notes dans SageMaker Studio Classic, consultez la section **Créer un bloc-notes depuis le menu Fichier** dans [Créer ou ouvrir un bloc-notes Amazon SageMaker Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-create-open.html#notebooks-create-file-menu).

      Pour obtenir la liste des images disponibles, consultez [Images Docker prises en charge](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-container.html).

1. Installez le SDK SageMaker Python.

   Pour annoter votre code avec la fonction @remote dans un bloc-notes SageMaker Studio Classic, le SDK SageMaker Python doit être installé. Installez le SDK SageMaker Python, comme indiqué dans l'exemple de code suivant.

   ```
   !pip install sagemaker
   ```

1. Utilisez @remote decorator pour exécuter des fonctions dans le cadre d'une tâche SageMaker de formation.

   Pour exécuter votre code ML local, créez d'abord un fichier de dépendances pour indiquer à SageMaker AI où localiser votre code local. Pour ce faire, procédez comme suit :

   1. Dans la zone de travail principale de SageMaker Studio Classic Launcher, dans **Utilitaires et fichiers**, sélectionnez **Fichier texte**. Cela ouvre un nouvel onglet avec un fichier texte appelé `untitled.txt.`. 

      Pour plus d'informations sur l'interface utilisateur (UI) de SageMaker Studio Classic, consultez la section [Présentation de l'interface utilisateur d'Amazon SageMaker Studio Classic](https://docs.aws.amazon.com//sagemaker/latest/dg/studio-ui.html).

   1. Renommez `untitled.txt ` en `requirements.txt`.

   1. Ajoutez toutes les dépendances requises pour le code ainsi que la bibliothèque SageMaker AI à`requirements.txt`. 

      Un exemple de code minimal pour `requirements.txt` pour l’exemple de fonction `divide` est fourni dans la section suivante, comme suit.

      ```
      sagemaker
      ```

   1. Exécutez votre code avec le décorateur distant en transmettant le fichier de dépendances, comme suit.

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

      Pour des exemples de code supplémentaires, consultez le bloc-notes d’exemple [quick\$1start.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb).

      Si vous utilisez déjà un bloc-notes SageMaker Studio Classic et que vous installez le SDK Python conformément aux instructions de la section **2. Installez le SDK SageMaker Python**, vous devez redémarrer votre noyau. Pour plus d'informations, consultez [Utiliser la barre d'outils SageMaker Studio Classic Notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-menu.html) dans le manuel *Amazon SageMaker AI Developer Guide*.

### Exécutez votre code depuis un SageMaker bloc-notes Amazon
<a name="train-remote-decorator-env-notebook"></a>

Vous pouvez annoter votre code ML local à partir d'une instance de SageMaker bloc-notes. Les instructions suivantes montrent comment créer une instance de bloc-notes avec un noyau personnalisé, installer le SDK SageMaker Python et annoter votre code avec le décorateur.

1. Créez une instance de bloc-notes avec un noyau `conda` personnalisé.

   Vous pouvez annoter votre code ML local à l'aide d'un décorateur @remote à utiliser dans le cadre d'une tâche de SageMaker formation. Vous devez d'abord créer et personnaliser une instance de SageMaker bloc-notes pour utiliser un noyau avec Python version 3.7 ou supérieure, jusqu'à 3.10.x. Pour ce faire, procédez comme suit :

   1. Ouvrez la console SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

   1. Dans le panneau de navigation de gauche, choisissez **Bloc-notes** pour développer ses options.

   1. Choisissez **Instances de blocs-notes** parmi les options étendues.

   1. Choisissez le bouton **Créer une instance de bloc-notes**. Une nouvelle page s’ouvre.

   1. Pour **Nom de l’instance de bloc-notes**, entrez un nom de 63 caractères maximum sans espaces. Les caractères valides sont : **A-Z**, **a-z**, **0-9** et **.****:****\$1****=****@**** \$1****%****-** (trait d’union).

   1. Dans la boîte de dialogue **Paramètres d’instances de blocs-notes**, développez la flèche droite à côté de **Configuration supplémentaire**.

   1. Sous **Configuration du cycle de vie – facultatif**, développez la flèche vers le bas et sélectionnez **Créer une nouvelle configuration de cycle de vie**. Cela ouvre une nouvelle boîte de dialogue.

   1. Pour **Nom**, entrez un nom pour vos paramètres de configuration.

   1. Dans la boîte de dialogue **Scripts**, dans l’onglet **Démarrer le bloc-notes**, remplacez le contenu existant de la zone de texte par le script suivant.

      ```
      #!/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. Dans la boîte de dialogue **Scripts**, dans l’onglet **Créer un bloc-notes**, remplacez le contenu existant de la zone de texte par le script suivant.

      ```
      #!/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. Choisissez le bouton **Créer une configuration** en bas à droite de la fenêtre.

   1. Choisissez le bouton **Créer une instance de bloc-notes** en bas à droite de la fenêtre.

   1. Attendez que le **statut de l'instance du** bloc-notes passe de **En attente** à **InService**.

1. Créez un bloc-notes Jupyter dans l’instance de bloc-notes.

   Les instructions suivantes montrent comment créer un bloc-notes Jupyter à l'aide de Python 3.10 dans votre instance nouvellement créée. SageMaker 

   1. Une fois que le **statut** de l'instance de bloc-notes de l'étape précédente est défini **InService**, procédez comme suit : 

      1. Sélectionnez **Ouvrir Jupyter** sous **Actions** dans la ligne contenant le **Nom** de l’instance de bloc-notes que vous venez de créer. Cela ouvre un nouveau serveur Jupyter.

   1. Sur le serveur Jupyter, sélectionnez **Nouveau** dans le menu en haut à droite. 

   1. Depuis la flèche vers le bas, sélectionnez **conda\$1custom\$1python310**. Cela crée un nouveau bloc-notes Jupyter qui utilise un noyau Python 3.10. Ce nouveau bloc-notes Jupyter peut désormais être utilisé de la même manière qu’un bloc-notes Jupyter local. 

1. Installez le SDK SageMaker Python.

   Une fois que votre environnement virtuel est en cours d'exécution, installez le SDK SageMaker Python à l'aide de l'exemple de code suivant.

   ```
   !pip install sagemaker
   ```

1. Utilisez un décorateur @remote pour exécuter des fonctions dans une tâche de SageMaker formation.

   Lorsque vous annotez votre code ML local à l'aide d'un décorateur @remote intégré au SageMaker bloc-notes, SageMaker training interprète automatiquement la fonction de votre code et l'exécute en tant que tâche de SageMaker formation. Configurez votre bloc-notes en procédant comme suit :

   1. Sélectionnez le nom du noyau dans le menu du bloc-notes depuis l'instance du SageMaker bloc-notes que vous avez créée à l'étape 1, **Création d'une instance de SageMaker bloc-notes avec un noyau personnalisé**.

      Pour plus d’informations, consultez [Modifier une image ou un noyau](https://docs.aws.amazon.com/sagemaker/latest/dg/notebooks-run-and-manage-change-image.html). 

   1. Depuis la flèche vers le bas, choisissez un noyau `conda` personnalisé qui utilise la version 3.7 ou ultérieure de Python. 

      Par exemple, la sélection de `conda_custom_python310` choisit le noyau pour Python 3.10.

   1. Choisissez **Select (Sélectionner)**.

   1. Attendez que le statut du noyau s’affiche comme inactif, ce qui indique que le noyau a démarré.

   1. Sur la page d’accueil du serveur Jupyter, sélectionnez **Nouveau** dans le menu en haut à droite.

   1. À côté de la flèche vers le bas, sélectionnez **Fichier texte**. Cela crée un nouveau fichier texte appelé `untitled.txt.`.

   1. Renommez `untitled.txt` `requirements.txt` et ajoutez-y toutes les dépendances requises pour le code avec `sagemaker`.

   1. Exécutez votre code avec le décorateur distant en transmettant le fichier de dépendances, comme suit.

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

      Pour des exemples de code supplémentaires, consultez le bloc-notes d’exemple [quick\$1start.ipnyb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-remote-function/quick_start/quick_start.ipynb).

### Exécution de votre code depuis votre IDE local
<a name="train-remote-decorator-env-ide"></a>

Vous pouvez annoter votre code de machine learning local avec un décorateur @remote dans votre IDE local préféré. Les étapes suivantes indiquent les conditions préalables nécessaires, comment installer le kit SDK Python et comment annoter votre code avec le décorateur @remote.

1. Installez les prérequis en configurant le AWS Command Line Interface (AWS CLI) et en créant un rôle, comme suit :
   + Connectez-vous à un domaine SageMaker AI en suivant les instructions de la section **AWS CLI Prérequis** de la section [Configurer les prérequis d'Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-set-up.html#gs-cli-prereq).
   + Créez un rôle IAM en suivant la section **Créer un rôle d'exécution** de [SageMaker AI Roles](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html).

1. Créez un environnement virtuel en utilisant l'un PyCharm ou l'autre ou `conda` en utilisant Python version 3.7 ou supérieure, jusqu'à 3.10.x.
   + Configurez un environnement virtuel en procédant PyCharm comme suit :

     1. Sélectionnez **Fichier** dans le menu principal.

     1. Choisissez **New Project (Nouveau projet)**.

     1. Choisissez **Conda** dans la flèche vers le bas sous **Nouvel environnement utilisant**.

     1. Dans le champ correspondant à la **version Python**, utilisez la flèche vers le bas pour sélectionner la version 3.7 ou ultérieure de Python. Vous pouvez aller jusqu’à la version 3.10.x dans la liste.  
![\[\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/training-pycharm-ide.png)
   + Si Anaconda est installé, vous pouvez configurer un environnement virtuel avec `conda`, comme suit :
     + Ouvrez une interface de terminal d’invite Anaconda.
     + Créez et activez un nouvel environnement `conda` à l’aide de la version 3.7 ou ultérieure de Python, jusqu’à la version 3.10x. L’exemple de code suivant montre comment créer un environnement `conda` avec la version 3.10 de Python.

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

1. Installez le SDK SageMaker Python.

   Pour intégrer votre code à partir de votre IDE préféré, vous devez disposer d’un environnement virtuel configuré à l’aide de la version 3.7 ou ultérieure de Python, jusqu’à la version 3.10x. Vous avez également besoin d’une image de conteneur compatible. Installez le SDK SageMaker Python à l'aide de l'exemple de code suivant.

   ```
   pip install sagemaker
   ```

1. Encapsulez votre code dans le décorateur @remote. Le SDK SageMaker Python interprétera automatiquement la fonction de votre code et l'exécutera en tant que tâche d' SageMakerapprentissage. Les exemples de code suivants montrent comment importer les bibliothèques nécessaires, configurer une SageMaker session et annoter une fonction avec le décorateur @remote.

   Vous pouvez exécuter votre code en fournissant directement les dépendances nécessaires ou en utilisant les dépendances de l’environnement `conda` actif.
   + Pour fournir directement les dépendances, procédez comme suit :
     + Créez un fichier `requirements.txt` dans le répertoire de travail où réside le code.
     + Ajoutez toutes les dépendances requises pour le code avec la SageMaker bibliothèque. La section suivante fournit un exemple de code minimal pour `requirements.txt` pour l’exemple de fonction `divide`.

       ```
       sagemaker
       ```
     + Exécutez votre code avec le décorateur @remote en transmettant le fichier de dépendances. Dans l'exemple de code suivant, remplacez-le `The IAM role name` par un ARN de rôle Gestion des identités et des accès AWS (IAM) que vous SageMaker souhaitez utiliser pour exécuter votre tâche.

       ```
       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))
       ```
   + Pour utiliser les dépendances de l’environnement `conda` actif, utilisez la valeur `auto_capture` du paramètre `dependencies`, comme indiqué ci-dessous.

     ```
     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))
     ```
**Note**  
Vous pouvez également implémenter le code précédent dans un bloc-notes Jupyter. PyCharm L'édition professionnelle prend en charge Jupyter de manière native. Pour plus d'informations, consultez le [support des ordinateurs portables Jupyter](https://www.jetbrains.com/help/pycharm/ipython-notebook-support.html) dans PyCharm la documentation.