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.
# Lift-and-shift Code Python avec le décorateur @step
Le décorateur `@step` est une fonctionnalité qui convertit votre code de machine learning (ML) local en une ou plusieurs étapes de pipeline. Vous pouvez écrire votre fonction ML comme vous le feriez pour n’importe quel projet ML. Une fois testée localement ou en tant que tâche de formation à l'aide du `@remote` décorateur, vous pouvez convertir la fonction en une étape de pipeline d' SageMaker IA en ajoutant un `@step` décorateur. Vous pouvez alors transmettre à Pipelines la sortie de l’appel de fonction décorée avec `@step` en tant qu’étape pour créer et exécuter un pipeline. Vous pouvez chaîner une série de fonctions avec le décorateur `@step` pour créer également un pipeline de graphe orienté acyclique (DAG) à plusieurs étapes.
La configuration permettant d’utiliser le décorateur `@step` est la même que celle pour utiliser le décorateur `@remote`. Vous pouvez vous reporter à la documentation des fonctions à distance pour plus de détails sur la [configuration de l’environnement](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator.html#train-remote-decorator-env) et sur l’[utilisation d’un fichier de configuration](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html) pour définir des valeurs par défaut. Pour plus d’informations sur le décorateur `@step`, consultez [sagemaker.workflow.function\$1step.step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.step).
Pour consulter des exemples de blocs-notes illustrant l’utilisation du décorateur `@step`, consultez les [exemples de blocs-notes du décorateur @step](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-pipelines/step-decorator).
Les sections suivantes expliquent comment annoter votre code ML local à l’aide d’un décorateur `@step` pour créer une étape, créer et exécuter un pipeline utilisant cette étape, et personnaliser l’expérience pour votre cas d’utilisation.
**Topics**
+ [Création d’un pipeline avec des fonctions décorées avec `@step`](pipelines-step-decorator-create-pipeline.md)
+ [Exécuter un pipeline](pipelines-step-decorator-run-pipeline.md)
+ [Configuration de votre pipeline](pipelines-step-decorator-cfg-pipeline.md)
+ [Bonnes pratiques](pipelines-step-decorator-best.md)
+ [Limitations](pipelines-step-decorator-limit.md)
# Création d’un pipeline avec des fonctions décorées avec `@step`
Vous pouvez créer un pipeline en convertissant les fonctions Python en étapes de pipeline à l’aide du décorateur `@step`, en créant des dépendances entre ces fonctions pour créer un graphe de pipeline (ou graphe orienté acyclique (DAG)) et en transmettant les nœuds terminaux de ce graphe sous forme de liste d’étapes au pipeline. Les sections suivantes expliquent cette procédure en détail avec des exemples.
**Topics**
+ [Conversion d’une fonction en étape](#pipelines-step-decorator-run-pipeline-convert)
+ [Création de dépendances entre les étapes](#pipelines-step-decorator-run-pipeline-link)
+ [Utilisation de `ConditionStep` avec des étapes décorées avec `@step`](#pipelines-step-decorator-condition)
+ [Définition d’un pipeline à l’aide de la sortie `DelayedReturn` des étapes](#pipelines-step-define-delayed)
+ [Création d’un pipeline](#pipelines-step-decorator-pipeline-create)
## Conversion d’une fonction en étape
Pour créer une étape à l’aide du décorateur `@step`, annotez la fonction avec `@step`. L’exemple suivant illustre une fonction décorée avec `@step` qui prétraite les données.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
step_process_result = preprocess(raw_data)
```
Lorsque vous invoquez une fonction `@step` décorée, SageMaker AI renvoie une `DelayedReturn` instance au lieu d'exécuter la fonction. Une instance `DelayedReturn` est un proxy pour le retour réel de cette fonction. L’instance `DelayedReturn` peut être transmise à une autre fonction en tant qu’argument ou directement à une instance de pipeline en tant qu’étape. Pour plus d'informations sur la `DelayedReturn` classe, consultez [sagemaker.workflow.function\$1step. DelayedReturn](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.DelayedReturn).
## Création de dépendances entre les étapes
Lorsque vous créez une dépendance entre deux étapes, vous créez une connexion entre les étapes de votre graphe de pipeline. Les sections suivantes présentent plusieurs manières de créer une dépendance entre les étapes de votre pipeline.
### Dépendances des données via des arguments d’entrée
Le fait de transmettre la sortie `DelayedReturn` d’une fonction en entrée d’une autre fonction crée automatiquement une dépendance de données dans le graphique DAG du pipeline. Dans l’exemple suivant, la transmission de la sortie `DelayedReturn` de la fonction `preprocess` à la fonction `train` crée une dépendance entre `preprocess` et `train`.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
@step
def train(training_data):
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train(step_process_result)
```
L’exemple précédent définit une fonction d’entraînement qui est décorée avec `@step`. Lorsque cette fonction est invoquée, elle reçoit la sortie `DelayedReturn` de l’étape de pipeline de prétraitement en entrée. L’invocation de la fonction d’entraînement renvoie une autre instance `DelayedReturn`. Cette instance contient les informations sur toutes les étapes précédentes, définies dans cette fonction (c’est-à-dire l’étape `preprocess` de cet exemple), qui forment le graphique DAG du pipeline.
Dans l’exemple précédent, la fonction `preprocess` renvoie une valeur unique. Pour des types de retour plus complexes tels que des listes ou des tuples, reportez-vous à [Limitations](pipelines-step-decorator-limit.md).
### Définition de dépendances personnalisées
Dans l’exemple précédent, la fonction `train` a reçu la sortie `DelayedReturn` de `preprocess` et a créé une dépendance. Si vous souhaitez définir cette dépendance de manière explicite sans transmettre la sortie de l’étape précédente, utilisez la fonction `add_depends_on` avec l’étape. Vous pouvez utiliser la fonction `get_step()` pour extraire l’étape sous-jacente depuis son instance `DelayedReturn`, puis appeler `add_depends_on` avec la dépendance en entrée. Pour visualiser la définition de la fonction `get_step()`, consultez [sagemaker.workflow.step\$1outputs.get\$1step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_outputs.get_step). L’exemple suivant montre comment créer une dépendance entre `preprocess` et `train` en utilisant `get_step()` et `add_depends_on()`.
```
from sagemaker.workflow.step_outputs import get_step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
processed_data = ..
return s3.upload(processed_data)
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train()
get_step(step_train_result).add_depends_on([step_process_result])
```
### Transmission de données depuis et vers une fonction décorée avec `@step` vers une étape de pipeline traditionnelle
Vous pouvez créer un pipeline qui inclut une étape décorée avec `@step` et une étape de pipeline traditionnelle et qui transmet des données entre les deux. Par exemple, vous pouvez utiliser `ProcessingStep` pour traiter les données et transmettre le résultat à la fonction d’entraînement décorée avec `@step`. Dans l’exemple suivant, une étape d’entraînement décorée avec `@step` fait référence à la sortie d’une étape de traitement.
```
# Define processing step
from sagemaker.sklearn.processing import SKLearnProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
sklearn_processor = SKLearnProcessor(
framework_version='1.2-1',
role='arn:aws:iam::123456789012:role/SagemakerExecutionRole',
instance_type='ml.m5.large',
instance_count='1',
)
inputs = [
ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
]
outputs = [
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
]
process_step = ProcessingStep(
name="MyProcessStep",
step_args=sklearn_processor.run(inputs=inputs, outputs=outputs,code='preprocessing.py'),
)
```
```
# Define a @step-decorated train step which references the
# output of a processing step
@step
def train(train_data_path, test_data_path):
...
return trained_model
step_train_result = train(
process_step.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
process_step.properties.ProcessingOutputConfig.Outputs["test"].S3Output.S3Uri,
)
```
## Utilisation de `ConditionStep` avec des étapes décorées avec `@step`
Pipelines prend en charge une classe `ConditionStep` qui évalue les résultats des étapes précédentes pour décider de l’action à entreprendre dans le pipeline. Vous pouvez également utiliser `ConditionStep` avec une étape décorée avec `@step`. Pour utiliser la sortie d’une étape `@step` quelconque décorée avec `ConditionStep`, entrez la sortie de cette étape en tant qu’argument de `ConditionStep`. Dans l’exemple suivant, l’étape de condition reçoit la sortie de l’étape d’évaluation des modèles décorée avec `@step`.
```
# Define steps
@step(name="evaluate")
def evaluate_model():
# code to evaluate the model
return {
"rmse":rmse_value
}
@step(name="register")
def register_model():
# code to register the model
...
```
```
# Define ConditionStep
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.conditions import ConditionGreaterThanOrEqualTo
from sagemaker.workflow.fail_step import FailStep
conditionally_register = ConditionStep(
name="conditional_register",
conditions=[
ConditionGreaterThanOrEqualTo(
# Output of the evaluate step must be json serializable
left=evaluate_model()["rmse"], #
right=5,
)
],
if_steps=[FailStep(name="Fail", error_message="Model performance is not good enough")],
else_steps=[register_model()],
)
```
## Définition d’un pipeline à l’aide de la sortie `DelayedReturn` des étapes
Vous définissez un pipeline de la même manière, que vous utilisiez ou non un décorateur `@step`. Lorsque vous transmettez une instance `DelayedReturn` à votre pipeline, vous n’avez pas besoin de transmettre la liste complète des étapes pour générer le pipeline. Le kit SDK déduit automatiquement les étapes précédentes en fonction des dépendances que vous définissez. Toutes les étapes précédentes des objets `Step` que vous avez transmis au pipeline ou aux objets `DelayedReturn` sont incluses dans le graphique du pipeline. Dans l’exemple suivant, le pipeline reçoit l’objet `DelayedReturn` pour la fonction `train`. SageMaker L'IA ajoute l'`preprocess`étape, en tant qu'étape précédente de`train`, au graphe du pipeline.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=,
)
```
S’il n’existe aucune donnée ou dépendance personnalisée entre les étapes et que vous exécutez plusieurs étapes en parallèle, le graphe du pipeline comporte plusieurs nœuds terminaux. Transmettez tous ces nœuds terminaux dans une liste à l’argument `steps` de votre définition de pipeline, comme indiqué dans l’exemple suivant :
```
@step
def process1():
...
return data
@step
def process2():
...
return data
step_process1_result = process1()
step_process2_result = process2()
pipeline = Pipeline(
name="",
steps=[step_process1_result, step_process2_result],
sagemaker_session=sagemaker-session,
)
```
Lorsque le pipeline s’exécute, les deux étapes s’exécutent en parallèle.
Vous transmettez uniquement les nœuds terminaux du graphe au pipeline, car ils contiennent des informations sur toutes les étapes précédentes définies par le biais de dépendances de données ou personnalisées. Lorsqu'elle compile le pipeline, l' SageMaker IA déduit également toutes les étapes suivantes qui forment le graphe du pipeline et ajoute chacune d'elles en tant qu'étape distincte au pipeline.
## Création d’un pipeline
Créez un pipeline en appelant `pipeline.create()`, comme illustré dans l’extrait suivant. Pour plus de détails sur `create()`, consultez [sagemaker.workflow.pipeline.Pipeline.create](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.create).
```
role = "pipeline-role"
pipeline.create(role)
```
Lorsque vous appelez`pipeline.create()`, SageMaker AI compile toutes les étapes définies dans le cadre de l'instance de pipeline. SageMaker L'IA télécharge la fonction sérialisée, les arguments et tous les autres artefacts liés aux étapes sur Amazon S3.
Les données résident dans le compartiment S3 selon la structure suivante :
```
s3_root_uri/
pipeline_name/
sm_rf_user_ws/
workspace.zip # archive of the current working directory (workdir)
step_name/
timestamp/
arguments/ # serialized function arguments
function/ # serialized function
pre_train_dependencies/ # any dependencies and pre_execution scripts provided for the step
execution_id/
step_name/
results # returned output from the serialized function including the model
```
`s3_root_uri`est défini dans le fichier de configuration SageMaker AI et s'applique à l'ensemble du pipeline. S'il n'est pas défini, le bucket SageMaker AI par défaut est utilisé.
**Note**
Chaque fois que l' SageMaker IA compile un pipeline, elle SageMaker enregistre les fonctions sérialisées, les arguments et les dépendances des étapes dans un dossier horodaté avec l'heure actuelle. Cela se produit chaque fois que vous exécutez `pipeline.create()`, `pipeline.update()`, `pipeline.upsert()` ou `pipeline.definition()`.
# Exécuter un pipeline
La page suivante décrit comment exécuter un pipeline avec Amazon SageMaker Pipelines, avec des ressources d' SageMaker IA ou localement.
Démarrez une nouvelle exécution de pipeline avec cette `pipeline.start()` fonction, comme vous le feriez pour une exécution de pipeline d' SageMaker IA traditionnelle. Pour en savoir plus sur la fonction `start()`, consultez [sagemaker.workflow.pipeline.Pipeline.start](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.start).
**Note**
Une étape définie à l’aide du décorateur `@step` s’exécute comme tâche d’entraînement. Par conséquent, tenez compte des limitations suivantes :
Limites d’instances et limites de tâches d’entraînement dans vos comptes. Mettez à jour vos limites en conséquence pour éviter tout problème de limitation ou de limite de ressources.
Les coûts monétaires associés à chaque exécution d’une étape d’entraînement dans le pipeline. Pour plus de détails, consultez les [ SageMaker tarifs Amazon](https://aws.amazon.com/sagemaker/pricing/).
## Extraction des résultats d’un pipeline exécuté localement
Pour afficher le résultat de n’importe quelle étape d’une exécution de pipeline, utilisez [execution.result()](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline._PipelineExecution.result ), comme indiqué dans l’extrait suivant :
```
execution = pipeline.start()
execution.result(step_name="train")
```
**Note**
Pipelines ne prend pas en charge `execution.result()` en mode local.
Vous ne pouvez récupérer les résultats que pour une seule étape à la fois. Si le nom de l'étape a été généré par l' SageMaker IA, vous pouvez le récupérer en appelant `list_steps` comme suit :
```
execution.list_step()
```
## Exécution d’un pipeline localement
Vous pouvez exécuter un pipeline avec des étapes décorées avec `@step` localement, comme vous le feriez pour des étapes de pipeline traditionnelles. Pour plus de détails sur les exécutions de pipelines en mode local, consultez [Exécution de pipelines en mode local](pipelines-local-mode.md). Pour utiliser le mode local, fournissez un élément `LocalPipelineSession` à la place d’un élément `SageMakerSession` dans la définition de votre pipeline, comme illustré dans l’exemple suivant :
```
from sagemaker.workflow.function_step import step
from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.pipeline_context import LocalPipelineSession
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_train_result = train()
local_pipeline_session = LocalPipelineSession()
local_pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=local_pipeline_session # needed for local mode
)
local_pipeline.create(role_arn="role_arn")
# pipeline runs locally
execution = local_pipeline.start()
```
# Configuration de votre pipeline
Il est conseillé d'utiliser le fichier de configuration SageMaker AI pour définir les valeurs par défaut du pipeline. Pour plus d'informations sur le fichier de configuration SageMaker AI, consultez [Configuration et utilisation des valeurs par défaut avec le SDK SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#configuring-and-using-defaults-with-the-sagemaker-python-sdk). Toute configuration ajoutée au fichier de configuration s’applique à toutes les étapes du pipeline. Si vous souhaitez remplacer les options de l’une des étapes, fournissez de nouvelles valeurs dans les arguments du décorateur `@step`. La rubrique suivante explique comment configurer un fichier de configuration.
La configuration du décorateur `@step` dans le fichier de configuration est identique à celle du décorateur `@remote`. Pour configurer l’ARN du rôle de pipeline et les balises de pipeline dans le fichier de configuration, utilisez la section `Pipeline` illustrée dans l’extrait de code suivant :
```
SchemaVersion: '1.0'
SageMaker:
Pipeline:
RoleArn: 'arn:aws:iam::555555555555:role/IMRole'
Tags:
- Key: 'tag_key'
Value: 'tag_value'
```
Vous pouvez également remplacer la plupart des valeurs par défaut que vous pouvez définir dans le fichier de configuration, en transmettant de nouvelles valeurs au décorateur `@step`. Par exemple, vous pouvez remplacer le type d’instance défini dans le fichier de configuration pour votre étape de prétraitement, comme illustré dans l’exemple suivant :
```
@step(instance_type="ml.m5.large")
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
```
Quelques arguments ne figurent pas dans la liste des paramètres du `@step` décorateur. Ils peuvent être configurés pour l'ensemble du pipeline uniquement via le fichier de configuration SageMaker AI. Ils sont répertoriés comme suit :
+ `sagemaker_session`(`sagemaker.session.Session`) : session d' SageMaker IA sous-jacente à laquelle l' SageMaker IA délègue les appels de service. Si elle n’est pas spécifiée, une session est créée à l’aide d’une configuration par défaut, comme suit :
```
SageMaker:
PythonSDK:
Modules:
Session:
DefaultS3Bucket: 'default_s3_bucket'
DefaultS3ObjectKeyPrefix: 'key_prefix'
```
+ `custom_file_filter` (`CustomFileFilter)` : objet `CustomFileFilter` qui spécifie les répertoires et fichiers locaux à inclure dans l’étape du pipeline. S’il n’est pas spécifié, la valeur utilisée par défaut est `None`. Pour que `custom_file_filter` prenne effet, vous devez définir `IncludeLocalWorkdir` sur `True`. L’exemple suivant montre une configuration qui ignore tous les fichiers de bloc-notes, ainsi que les fichiers et répertoires nommés `data`.
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
IncludeLocalWorkDir: true
CustomFileFilter:
IgnoreNamePatterns: # files or directories to ignore
- "*.ipynb" # all notebook files
- "data" # folder or file named "data"
```
Pour plus de détails sur la façon d’utiliser `IncludeLocalWorkdir` avec `CustomFileFilter`, consultez [Utilisation d’un code modulaire avec le décorateur @remote](train-remote-decorator-modular.md).
+ `s3_root_uri (str)`: le dossier racine Amazon S3 dans lequel SageMaker AI télécharge les archives de code et les données. S'il n'est pas spécifié, le bucket SageMaker AI par défaut est utilisé.
+ `s3_kms_key (str)` : clé utilisée pour chiffrer les données d’entrée et de sortie. Vous ne pouvez configurer cet argument que dans le fichier de configuration SageMaker AI et l'argument s'applique à toutes les étapes définies dans le pipeline. S’il n’est pas spécifié, la valeur utilisée par défaut est `None`. Consultez l’extrait de code suivant pour un exemple de configuration de clé KMS S3 :
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
S3KmsKeyId: 's3kmskeyid'
S3RootUri: 's3://amzn-s3-demo-bucket/my-project
```
# Bonnes pratiques
Les sections suivantes suggèrent de bonnes pratiques à suivre lorsque vous utilisez le décorateur `@step` pour les étapes de votre pipeline.
## Utilisation de groupes à chaud
Pour accélérer les exécutions des étapes du pipeline, utilisez la fonctionnalité des groupes à chaud fournie pour les tâches d’entraînement. Vous pouvez activer la fonctionnalité des groupes à chaud en fournissant l’argument `keep_alive_period_in_seconds` au décorateur `@step`, comme illustré dans l’extrait de code suivant :
```
@step(
keep_alive_period_in_seconds=900
)
```
Pour plus d’informations sur les groupes d’instances pré-initialisées, consultez [SageMaker Piscines d'eau chaude gérées par l'IA](train-warm-pools.md).
## Structuration de votre répertoire
Il est conseillé d’utiliser des modules de code lors de l’utilisation du décorateur `@step`. Placez le module `pipeline.py`, dans lequel vous invoquez les fonctions d’étape et définissez le pipeline, à la racine de l’espace de travail. La structure recommandée se présente comme suit :
```
.
├── config.yaml # the configuration file that define the infra settings
├── requirements.txt # dependencies
├── pipeline.py # invoke @step-decorated functions and define the pipeline here
├── steps/
| ├── processing.py
| ├── train.py
├── data/
├── test/
```
# Limitations
Les sections suivantes décrivent les limites dont vous devez tenir compte lorsque vous utilisez le décorateur `@step` pour les étapes de votre pipeline.
## Limites des arguments des fonctions
Lorsque vous transmettez un argument d’entrée à la fonction décorée avec `@step`, les limites suivantes s’appliquent :
+ Vous pouvez transmettre les objets `DelayedReturn`, `Properties` (d’étapes d’autres types), `Parameter` et `ExecutionVariable` aux fonctions décorées avec `@step` en tant qu’arguments. Mais les fonctions décorées avec `@step` ne prennent pas en charge les objets `JsonGet` et `Join` en tant qu’arguments.
+ Vous ne pouvez pas accéder directement à une variable de pipeline à partir d’une fonction `@step`. L’exemple suivant génère une erreur :
```
param = ParameterInteger(name="", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ Vous ne pouvez pas imbriquer une variable de pipeline dans un autre objet et la transmettre à une fonction `@step`. L’exemple suivant génère une erreur :
```
param = ParameterInteger(name="", default_value=10)
@step
def func(arg):
print(arg)
func(arg=(param,)) # this raises a SerializationError because param is nested in a tuple
```
+ Les entrées et sorties d’une fonction étant sérialisées, le type de données pouvant être transmis en entrée ou en sortie à partir d’une fonction est soumis à des restrictions. Consultez la section *Sérialisation et désérialisation des données* de [Invoquer une fonction à distance](train-remote-decorator-invocation.md) pour plus de détails. Les mêmes restrictions s’appliquent aux fonctions décorées avec `@step`.
+ Tout objet doté d’un client boto ne peut pas être sérialisé. Vous ne pouvez donc pas transmettre de tels objets en entrée ou en sortie à partir d’une fonction décorée avec `@step`. Par exemple, les classes clientes du SDK SageMaker Python telles que `Estimator``Predictor`, et ne `Processor` peuvent pas être sérialisées.
## Importations de fonctions
Vous devez importer les bibliothèques requises par l’étape à l’intérieur plutôt qu’à l’extérieur de la fonction. Si vous les importez à l’échelle mondiale, vous risquez une collision d’importation lors de la sérialisation de la fonction. Par exemple, `sklearn.pipeline.Pipeline` pourrait être remplacé par `sagemaker.workflow.pipeline.Pipeline`.
## Référencement des membres enfants de la valeur de retour de la fonction
Si vous référencez des membres enfants d’une valeur de retour d’une fonction décorée avec `@step`, les limites suivantes s’appliquent :
+ Vous pouvez référencer les membres enfants avec `[]` si l’objet `DelayedReturn` représente un tuple, une liste ou un dict, comme indiqué dans l’exemple suivant :
```
delayed_return[0]
delayed_return["a_key"]
delayed_return[1]["a_key"]
```
+ Vous ne pouvez pas décompresser la sortie d’un tuple ou d’une liste, car la longueur exacte du tuple ou de la liste sous-jacent(e) ne peut pas être connue lorsque vous invoquez la fonction. L’exemple suivant génère une erreur :
```
a, b, c = func() # this raises ValueError
```
+ Vous ne pouvez pas itérer sur un objet `DelayedReturn`. L’exemple suivant déclenche une erreur :
```
for item in func(): # this raises a NotImplementedError
```
+ Vous ne pouvez pas référencer des membres enfants arbitraires avec « `.` ». L’exemple suivant génère une erreur :
```
delayed_return.a_child # raises AttributeError
```
## Fonctionnalités de pipeline existantes qui ne sont pas prises en charge
Vous ne pouvez pas utiliser le décorateur `@step` avec les fonctionnalités de pipeline suivantes :
+ [Mise en cache des étapes d’un pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-caching.html)
+ [Fichiers de propriétés](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html#build-and-manage-propertyfile-property)