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.

# Flux de travail des tâches de bloc-notes
<a name="create-notebook-auto-run-dag"></a>

Étant donné qu’une tâche de bloc-notes exécute votre code personnalisé, vous pouvez créer un pipeline incluant une ou plusieurs étapes de tâche de bloc-notes. Les flux de travail ML contiennent souvent plusieurs étapes, telles qu’une étape de traitement pour prétraiter les données, une étape d’entraînement pour générer votre modèle et une étape d’évaluation des modèles, entre autres. L’une des utilisations possibles des tâches de bloc-notes est de gérer le prétraitement. Vous pouvez avoir un bloc-notes qui effectue la transformation ou l’ingestion des données, une étape EMR qui effectue le nettoyage des données et une autre tâche de bloc-notes qui effectue la caractérisation de vos entrées avant de lancer une étape d’entraînement. Une tâche de bloc-notes peut nécessiter des informations issues des étapes précédentes du pipeline ou de la personnalisation spécifiée par l’utilisateur sous la forme de paramètres dans le bloc-notes d’entrée. Pour des exemples illustrant comment transmettre des variables et des paramètres d’environnement à votre bloc-notes et comment récupérer des informations à partir des étapes précédentes, consultez [Transmission d’informations vers et depuis votre étape de bloc-notes](create-notebook-auto-run-dag-seq.md).

Dans un autre cas d’utilisation, l’une de vos tâches de bloc-notes peut appeler un autre bloc-notes pour effectuer certaines tâches pendant l’exécution de votre bloc-notes. Dans ce scénario, vous devez spécifier ces blocs-notes sources en tant que dépendances avec votre étape de tâche de bloc-notes. Pour en savoir plus sur la manière d’appeler un autre bloc-notes, consultez [Invocation d’un autre bloc-notes dans votre tâche de bloc-notes](create-notebook-auto-run-dag-call.md).

Pour consulter des exemples de blocs-notes illustrant comment planifier des tâches de bloc-notes à l'aide du SDK SageMaker AI Python, consultez la section [Exemples de carnets de notes de blocs-notes](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-pipelines/notebook-job-step).

# Transmission d’informations vers et depuis votre étape de bloc-notes
<a name="create-notebook-auto-run-dag-seq"></a>

Les sections suivantes décrivent les méthodes permettant de transmettre des informations à votre bloc-notes sous forme de variables et de paramètres d’environnement.

## Transmission de variables d’environnement
<a name="create-notebook-auto-run-dag-seq-env-var"></a>

Transmettez des variables d’environnement sous forme de dictionnaire à l’argument `environment_variable` de votre `NotebookJobStep`, comme indiqué dans l’exemple suivant :

```
environment_variables = {"RATE": 0.0001, "BATCH_SIZE": 1000}

notebook_job_step = NotebookJobStep(
    ...
    environment_variables=environment_variables,
    ...
)
```

Vous pouvez utiliser les variables d’environnement dans le bloc-notes en utilisant `os.getenv()`, comme illustré dans l’exemple suivant :

```
# inside your notebook
import os
print(f"ParentNotebook: env_key={os.getenv('env_key')}")
```

## Transmission de paramètres
<a name="create-notebook-auto-run-dag-seq-param"></a>

Lorsque vous transmettez des paramètres à la première étape de tâche de bloc-notes dans votre instance `NotebookJobStep`, vous pouvez éventuellement vouloir baliser une cellule dans votre bloc-notes Jupyter pour indiquer où appliquer les nouveaux paramètres ou les remplacements de paramètres. Pour obtenir des instructions de balisage d’une cellule dans votre bloc-notes Jupyter, consultez [Paramétrer votre bloc-notes](notebook-auto-run-troubleshoot-override.md).

Vous transmettez les paramètres via le paramètre `parameters` de l’étape de tâche de bloc-notes, comme illustré dans l’extrait de code suivant :

```
notebook_job_parameters = {
    "company": "Amazon",
}

notebook_job_step = NotebookJobStep(
    ...
    parameters=notebook_job_parameters,
    ...
)
```

Dans votre bloc-notes d’entrée, vos paramètres sont appliqués après la cellule balisée par `parameters` ou au début du bloc-notes si aucune cellule n’est balisée.

```
# this cell is in your input notebook and is tagged with 'parameters'
# your parameters and parameter overrides are applied after this cell
company='default'
```

```
# in this cell, your parameters are applied
# prints "company is Amazon"
print(f'company is {company}')
```

## Extraction d’informations depuis une étape précédente
<a name="create-notebook-auto-run-dag-seq-interstep"></a>

La discussion suivante explique comment extraire des données d’une étape précédente pour les transmettre à votre étape de tâche de bloc-notes.

**Utilisation de l’attribut `properties`**

Vous pouvez utiliser les propriétés suivantes avec l’attribut `properties` de l’étape précédente :
+ `ComputingJobName` : nom de la tâche d’entraînement
+ `ComputingJobStatus` : statut de la tâche d’entraînement
+ `NotebookJobInputLocation` : emplacement Amazon S3 d’entrée
+ `NotebookJobOutputLocationPrefix` : chemin vers les résultats de votre tâche d’entraînement, plus précisément vers `{NotebookJobOutputLocationPrefix}/{training-job-name}/output/output.tar.gz`, contenant les résultats
+ `InputNotebookName` : nom de fichier du bloc-notes en entrée
+ `OutputNotebookName` : nom de fichier du bloc-notes de sortie (qui n’existe peut-être pas dans le dossier de sortie de la tâche d’entraînement en cas d’échec de la tâche)

L’extrait de code suivant montre comment extraire des paramètres de l’attribut properties.

```
notebook_job_step2 = NotebookJobStep(
    ....
    parameters={
        "step1_JobName": notebook_job_step1.properties.ComputingJobName,
        "step1_JobStatus": notebook_job_step1.properties.ComputingJobStatus,
        "step1_NotebookJobInput": notebook_job_step1.properties.NotebookJobInputLocation,
        "step1_NotebookJobOutput": notebook_job_step1.properties.NotebookJobOutputLocationPrefix,
    }
```

**Utilisez JsonGet**

Si vous souhaitez transmettre des paramètres autres que ceux mentionnés précédemment et que les sorties JSON de votre étape précédente se trouvent dans Amazon S3, utilisez `JsonGet`. `JsonGet` est un mécanisme général capable d’extraire directement des données de fichiers JSON dans Amazon S3.

Pour extraire des fichiers JSON dans Amazon S3 avec `JsonGet`, procédez comme suit :

1. Chargez votre fichier JSON sur Amazon S3. Si vos données sont déjà chargées sur Amazon S3, ignorez cette étape. L’exemple suivant montre le chargement d’un fichier JSON sur Amazon S3.

   ```
   import json
   from sagemaker.s3 import S3Uploader
   
   output = {
       "key1": "value1", 
       "key2": [0,5,10]
   }
               
   json_output = json.dumps(output)
   
   with open("notebook_job_params.json", "w") as file:
       file.write(json_output)
   
   S3Uploader.upload(
       local_path="notebook_job_params.json",
       desired_s3_uri="s3://path/to/bucket"
   )
   ```

1. Indiquez votre URI S3 et le chemin JSON vers la valeur que vous souhaitez extraire. Dans l’exemple suivant, `JsonGet` renvoie un objet représentant l’index 2 de la valeur associée à la clé `key2` (`10`).

   ```
   NotebookJobStep(
       ....
       parameters={
           # the key job_key1 returns an object representing the value 10
           "job_key1": JsonGet(
               s3_uri=Join(on="/", values=["s3:/", ..]),
               json_path="key2[2]" # value to reference in that json file
           ), 
           "job_key2": "Amazon" 
       }
   )
   ```

# Invocation d’un autre bloc-notes dans votre tâche de bloc-notes
<a name="create-notebook-auto-run-dag-call"></a>

Vous pouvez configurer un pipeline dans lequel une tâche de bloc-notes appelle un autre bloc-notes. Voici un exemple de pipeline comportant une étape de tâche de bloc-notes dans laquelle le bloc-notes appelle deux autres blocs-notes. Le bloc-notes d’entrée contient les lignes suivantes :

```
%run 'subfolder/notebook_to_call_in_subfolder.ipynb'
%run 'notebook_to_call.ipynb'
```

Transmettez ces blocs-notes dans vos instances `NotebookJobStep` avec `additional_dependencies`, comme indiqué dans l’extrait de code suivant. Notez que les chemins fournis pour les blocs-notes dans `additional_dependencies` sont fournis à partir de l’emplacement racine. Pour plus d'informations sur la manière dont l' SageMaker IA télécharge vos fichiers et dossiers dépendants sur Amazon S3 afin que vous puissiez fournir correctement les chemins d'accès à vos dépendances, consultez la description `additional_dependencies` dans [NotebookJobStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.notebook_job_step.NotebookJobStep).

```
input_notebook = "inputs/input_notebook.ipynb"
simple_notebook_path = "inputs/notebook_to_call.ipynb"
folder_with_sub_notebook = "inputs/subfolder"

notebook_job_step = NotebookJobStep(
    image_uri=image-uri,
    kernel_name=kernel-name,
    role=role-name,
    input_notebook=input_notebook,
    additional_dependencies=[simple_notebook_path, folder_with_sub_notebook],
    tags=tags,
)
```