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.
# Utiliser votre propre code de traitement
Vous pouvez installer des bibliothèques pour exécuter vos scripts dans votre propre conteneur de traitement ou, dans un scénario plus avancé, vous pouvez créer votre propre conteneur de traitement conformément au contrat d'exécution dans Amazon SageMaker AI. Pour plus d'informations sur les conteneurs dans SageMaker l'IA, consultez[Conteneurs Docker pour l’entraînement et le déploiement de modèles](docker-containers.md). Pour une spécification officielle définissant le contrat pour un conteneur Amazon SageMaker Processing, consultez[Création de votre propre conteneur de traitement (scénario avancé)](build-your-own-processing-container.md).
**Topics**
+ [Exécuter des scripts avec votre propre conteneur de traitement](processing-container-run-scripts.md)
+ [Création de votre propre conteneur de traitement (scénario avancé)](build-your-own-processing-container.md)
# Exécuter des scripts avec votre propre conteneur de traitement
Vous pouvez utiliser des scripts scikit-learn pour prétraiter les données et évaluer vos modèles. Pour savoir comment exécuter des scripts scikit-learn pour effectuer ces tâches, consultez l’exemple de bloc-notes [scikit-learn Processing](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation). Ce bloc-notes utilise la `ScriptProcessor` classe du SDK Amazon SageMaker Python pour le traitement.
L'exemple suivant montre un flux de travail général pour utiliser une classe `ScriptProcessor` avec votre propre conteneur de traitement. Le flux de travail montre comment créer votre propre image, créer votre conteneur et utiliser une classe `ScriptProcessor` pour exécuter un script de prétraitement Python avec le conteneur. La tâche de traitement traite vos données d'entrée et enregistre les données traitées dans Amazon Simple Storage Service (Amazon S3).
Avant d'utiliser les exemples suivants, vous devez disposer de vos propres données d'entrée et d'un script Python préparé pour traiter vos données. Pour un end-to-end exemple guidé de ce processus, reportez-vous au carnet d'exemples de [traitement scikit-learn](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation).
1. Créez un répertoire Docker et ajoutez le fichier Dockerfile utilisé pour créer le conteneur de traitement. Installez-y des pandas et scikit-learn. (Vous pouvez également installer vos propres dépendances avec une commande `RUN` similaire.)
```
mkdir docker
%%writefile docker/Dockerfile
FROM python:3.7-slim-buster
RUN pip3 install pandas==0.25.3 scikit-learn==0.21.3
ENV PYTHONUNBUFFERED=TRUE
ENTRYPOINT ["python3"]
```
1. Créez le conteneur à l'aide de la commande docker, créez un référentiel Amazon Elastic Container Registry (Amazon ECR) et envoyez l'image à Amazon ECR.
```
import boto3
account_id = boto3.client('sts').get_caller_identity().get('Account')
region = boto3.Session().region_name
ecr_repository = 'sagemaker-processing-container'
tag = ':latest'
processing_repository_uri = '{}.dkr.ecr.{}.amazonaws.com/{}'.format(account_id, region, ecr_repository + tag)
# Create ECR repository and push docker image
!docker build -t $ecr_repository docker
!aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin {account_id}.dkr.ecr.{region}.amazonaws.com
!aws ecr create-repository --repository-name $ecr_repository
!docker tag {ecr_repository + tag} $processing_repository_uri
!docker push $processing_repository_uri
```
1. Configurez le `ScriptProcessor` à partir du SDK SageMaker Python pour exécuter le script. Remplacez-le *image\$1uri* par l'URI de l'image que vous avez créée et remplacez-le par l'ARN d'un Gestion des identités et des accès AWS rôle *role\$1arn* ayant accès à votre compartiment Amazon S3 cible.
```
from sagemaker.processing import ScriptProcessor, ProcessingInput, ProcessingOutput
script_processor = ScriptProcessor(command=['python3'],
image_uri='image_uri',
role='role_arn',
instance_count=1,
instance_type='ml.m5.xlarge')
```
1. Exécutez le script. Remplacez-le *preprocessing.py* par le nom de votre propre script de traitement Python et remplacez-le *s3://path/to/my/input-data.csv* par le chemin Amazon S3 vers vos données d'entrée.
```
script_processor.run(code='preprocessing.py',
inputs=[ProcessingInput(
source='s3://path/to/my/input-data.csv',
destination='/opt/ml/processing/input')],
outputs=[ProcessingOutput(source='/opt/ml/processing/output/train'),
ProcessingOutput(source='/opt/ml/processing/output/validation'),
ProcessingOutput(source='/opt/ml/processing/output/test')])
```
Vous pouvez utiliser la même procédure avec n'importe quelle autre bibliothèque ou dépendance système. Vous pouvez également utiliser des images Docker existantes. Cela inclut les images que vous exécutez sur d'autres plateformes telles que [Kubernetes](https://kubernetes.io/).
# Création de votre propre conteneur de traitement (scénario avancé)
Vous pouvez fournir à Amazon SageMaker Processing une image Docker dotée de votre propre code et de vos propres dépendances pour exécuter vos charges de travail de traitement des données, d'ingénierie des fonctionnalités et d'évaluation de modèles. Vous trouverez ci-dessous des informations sur la façon de créer votre propre conteneur de traitement.
L'exemple suivant d'un Dockerfile génère un conteneur avec les bibliothèques Python scikit-learn et pandas que vous pouvez exécuter en tant que tâche de traitement.
```
FROM python:3.7-slim-buster
# Install scikit-learn and pandas
RUN pip3 install pandas==0.25.3 scikit-learn==0.21.3
# Add a Python script and configure Docker to run it
ADD processing_script.py /
ENTRYPOINT ["python3", "/processing_script.py"]
```
Pour un exemple de script de traitement, voir [Commencer SageMaker le traitement](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_processing/basic_sagemaker_data_processing/basic_sagemaker_processing.ipynb).
Créez et transférez cette image Docker vers un référentiel Amazon Elastic Container Registry (Amazon ECR) et assurez-vous que votre rôle SageMaker AI IAM peut extraire l'image depuis Amazon ECR. Vous pouvez ensuite exécuter cette image sur Amazon SageMaker Processing.
# Comment Amazon SageMaker Processing gère votre image de conteneur de traitement
Amazon SageMaker Processing exécute votre image de conteneur de traitement de la même manière que la commande suivante, où se `AppSpecification.ImageUri` trouve l'URI de l'image Amazon ECR que vous spécifiez lors d'une `CreateProcessingJob` opération.
```
docker run [AppSpecification.ImageUri]
```
Cette commande exécute la commande `ENTRYPOINT` configurée dans votre image Docker.
Vous pouvez également remplacer la commande entrypoint dans l'image ou donner des arguments de ligne de commande à votre commande entrypoint à l'aide des paramètres `AppSpecification.ContainerEntrypoint` et `AppSpecification.ContainerArgument` de votre demande `CreateProcessingJob`. La spécification de ces paramètres permet à Amazon SageMaker Processing d'exécuter le conteneur de la même manière que la commande suivante.
```
docker run --entry-point [AppSpecification.ContainerEntrypoint] [AppSpecification.ImageUri] [AppSpecification.ContainerArguments]
```
Par exemple, si vous spécifiez `ContainerEntrypoint` ce qui doit être `[python3, -v, /processing_script.py]` dans votre `CreateProcessingJob ` demande`[data-format, csv]`, Amazon SageMaker Processing exécute votre conteneur `ContainerArguments` à l'aide de la commande suivante.
```
python3 -v /processing_script.py data-format csv
```
Lors de la génération de votre conteneur de traitement, tenez compte des éléments suivants :
+ Amazon SageMaker Processing décide si la tâche se termine ou échoue en fonction du code de sortie de la commande exécutée. Une tâche de traitement se termine si tous les conteneurs de traitement quittent avec succès avec un code de sortie égal à 0 et échoue si l'un des conteneurs quitte avec un code de sortie différent de zéro.
+ Amazon SageMaker Processing vous permet de remplacer le point d'entrée du conteneur de traitement et de définir des arguments de ligne de commande comme vous le pouvez avec l'API Docker. Les images Docker peuvent également configurer les arguments d'entrée et de ligne de commande à l'aide des instructions `ENTRYPOINT` et CMD. La méthode dont les paramètres `ContainerEntrypoint` et `ContainerArgument` de `CreateProcessingJob` configurent le point d'entrée et les arguments d'une image Docker reflète la façon dont Docker remplace le point d'entrée et les arguments via l'API Docker :
+ En l'absence de `ContainerEntrypoint` et `ContainerArguments`, Processing utilise la valeur par défaut `ENTRYPOINT` ou CMD dans l'image.
+ Si `ContainerEntrypoint` est fourni, mais pas `ContainerArguments`, Processing exécute l'image avec le point d'entrée donné, et ignore les instructions `ENTRYPOINT` et CMD dans l'image.
+ Si `ContainerArguments` est fourni, mais pas `ContainerEntrypoint`, Processing exécute l'image avec l'instruction par défaut `ENTRYPOINT` dans l'image et avec les arguments fournis.
+ Si `ContainerEntrypoint` et `ContainerArguments` sont fournis, Processing exécute l'image avec le point d'entrée et les arguments donnés, et ignore les instructions `ENTRYPOINT` et le CMD dans l'image.
+ Vous devez utiliser le formulaire exec de l'instruction `ENTRYPOINT` dans votre Dockerfile (`ENTRYPOINT` `["executable", "param1", "param2"])`) au lieu du formulaire shell (`ENTRYPOINT`` command param1 param2`). Cela permet à votre conteneur de traitement de recevoir des signaux `SIGINT` et `SIGKILL` que Processing utilise pour arrêter les tâches de traitement avec l'API `StopProcessingJob`.
+ `/opt/ml`et tous ses sous-répertoires sont réservés par SageMaker AI. Lors de la création de votre image Docker de traitement, ne placez aucune des données requises par votre conteneur de traitement dans ces répertoires.
+ Si vous envisagez d'utiliser des périphériques GPU, assurez-vous que vos conteneurs sont compatibles avec nvidia-docker. Incluez uniquement la boîte à outils CUDA dans les conteneurs. Ne regroupez pas des pilotes NVIDIA avec l’image. Pour plus d’informations sur nvidia-docker, consultez [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
# Comment Amazon SageMaker Processing configure les entrées et sorties de votre conteneur de traitement
Lorsque vous créez une tâche de traitement à l'aide de l'opération `CreateProcessingJob`, vous pouvez spécifier plusieurs valeurs `ProcessingInput` et `ProcessingOutput`.
Vous utilisez le paramètre `ProcessingInput` pour spécifier un URI Amazon Simple Storage Service (Amazon S3) à partir duquel télécharger les données et un chemin d'accès dans votre conteneur de traitement vers lequel télécharger les données. Le paramètre `ProcessingOutput` configure un chemin d'accès dans votre conteneur de traitement à partir duquel télécharger les données et l'emplacement dans Amazon S3 où télécharger les données. Pour `ProcessingInput` et `ProcessingOutput`, le chemin dans le conteneur de traitement doit commencer par `/opt/ml/processing/ `.
Par exemple, vous pouvez créer une tâche de traitement avec un paramètre `ProcessingInput` qui télécharge les données de `s3://your-data-bucket/path/to/input/csv/data` vers `/opt/ml/processing/csv` dans votre conteneur de traitement, et un paramètre `ProcessingOutput` qui télécharge les données de `/opt/ml/processing/processed_csv` vers `s3://your-data-bucket/path/to/output/csv/data`. Dans ce cas, votre tâche de traitement lit les données d'entrée et écrit les données de sortie dans `/opt/ml/processing/processed_csv`. Les données écrites sont ensuite téléchargées vers ce chemin d'accès dans l'emplacement de sortie Amazon S3 spécifié.
**Important**
Les liens symboliques (symlinks) ne peuvent pas être utilisés pour télécharger des données de sortie vers Amazon S3. Les liens symboliques ne sont pas suivis lors du téléchargement des données de sortie.
# Comment Amazon SageMaker Processing fournit des journaux et des métriques pour votre conteneur de traitement
Lorsque votre conteneur de traitement écrit vers `stdout` ou`stderr`, Amazon SageMaker Processing enregistre le résultat de chaque conteneur de traitement et le place dans CloudWatch les journaux Amazon. Pour plus d’informations sur la journalisation, consultez [CloudWatch Journaux pour Amazon SageMaker AI](logging-cloudwatch.md).
Amazon SageMaker Processing fournit également CloudWatch des métriques pour chaque instance exécutant votre conteneur de traitement. Pour plus d’informations sur les métriques, consultez [Métriques Amazon SageMaker AI sur Amazon CloudWatch](monitoring-cloudwatch.md).
## Comment Amazon SageMaker Processing configure votre conteneur de traitement
Amazon SageMaker Processing fournit des informations de configuration à votre conteneur de traitement par le biais de variables d'environnement et de deux fichiers JSON `/opt/ml/config/resourceconfig.json` (`/opt/ml/config/processingjobconfig.json`et) à des emplacements prédéfinis dans le conteneur.
Lorsqu'une tâche de traitement démarre, elle utilise les variables d'environnement que vous avez spécifiées avec la carte `Environment` dans la demande `CreateProcessingJob`. Le fichier `/opt/ml/config/processingjobconfig.json` contient des informations sur les noms d'hôte de vos conteneurs de traitement et est également spécifié dans la demande `CreateProcessingJob`.
L'exemple suivant illustre le format du fichier `/opt/ml/config/processingjobconfig.json`.
```
{
"ProcessingJobArn": "",
"ProcessingJobName": "",
"AppSpecification": {
"ImageUri": "",
"ContainerEntrypoint": null,
"ContainerArguments": null
},
"Environment": {
"KEY": "VALUE"
},
"ProcessingInputs": [
{
"InputName": "input-1",
"S3Input": {
"LocalPath": "/opt/ml/processing/input/dataset",
"S3Uri": "",
"S3DataDistributionType": "FullyReplicated",
"S3DataType": "S3Prefix",
"S3InputMode": "File",
"S3CompressionType": "None",
"S3DownloadMode": "StartOfJob"
}
}
],
"ProcessingOutputConfig": {
"Outputs": [
{
"OutputName": "output-1",
"S3Output": {
"LocalPath": "/opt/ml/processing/output/dataset",
"S3Uri": "",
"S3UploadMode": "EndOfJob"
}
}
],
"KmsKeyId": null
},
"ProcessingResources": {
"ClusterConfig": {
"InstanceCount": 1,
"InstanceType": "ml.m5.xlarge",
"VolumeSizeInGB": 30,
"VolumeKmsKeyId": null
}
},
"RoleArn": "",
"StoppingCondition": {
"MaxRuntimeInSeconds": 86400
}
}
```
Le fichier `/opt/ml/config/resourceconfig.json` contient des informations sur les noms d'hôte de vos conteneurs de traitement. Utilisez les noms d'hôte suivants lors de la création ou de l'exécution du code de traitement distribué.
```
{
"current_host": "algo-1",
"hosts": ["algo-1","algo-2","algo-3"]
}
```
N'utilisez pas les informations relatives aux noms d'hôte contenues dans `/etc/hostname` ou `/etc/hosts`, car elles peuvent être inexactes.
Les informations sur le nom d'hôte peuvent ne pas être immédiatement disponibles pour le conteneur de traitement. Nous vous recommandons d’ajouter une politique de nouvelle tentative aux opérations de résolution de nom d’hôte quand les nœuds deviennent disponibles dans le cluster.
# Enregistrement et accès aux informations de métadonnées relatives à votre tâche de traitement
Pour enregistrer les métadonnées du conteneur de traitement après l'avoir quitté, les conteneurs peuvent écrire du texte codé UTF-8 dans le fichier `/opt/ml/output/message`. Une fois que la tâche de traitement affiche un état du terminal (« `Completed` », « `Stopped` » ou « `Failed` »), le champ « `ExitMessage` » dans [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html) contient le premier Ko de ce fichier. Accédez à cette partie initiale du fichier avec un appel à [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html), qui la renvoie via le paramètre `ExitMessage`. Pour les tâches de traitement ayant échoué, vous pouvez utiliser ce champ pour indiquer pourquoi le conteneur de traitement a échoué
**Important**
N'écrivez pas de données sensibles dans le fichier `/opt/ml/output/message`.
Si les données de ce fichier ne sont pas codées en UTF-8, la tâche échoue et renvoie une erreur `ClientError`. Si plusieurs conteneurs quittent avec une erreur `ExitMessage,`, le contenu de l'erreur `ExitMessage` de chaque conteneur de traitement est concaténé, puis tronqué à 1 Ko.
# Exécutez votre conteneur de traitement à l'aide du SDK SageMaker AI Python
Vous pouvez utiliser le SDK SageMaker Python pour exécuter votre propre traitement d'image à l'aide de la `Processor` classe. L'exemple suivant montre comment exécuter votre propre conteneur de traitement avec une entrée depuis Amazon Simple Storage Service (Amazon S3) et une sortie vers Amazon S3.
```
from sagemaker.processing import Processor, ProcessingInput, ProcessingOutput
processor = Processor(image_uri='',
role=role,
instance_count=1,
instance_type="ml.m5.xlarge")
processor.run(inputs=[ProcessingInput(
source='',
destination='/opt/ml/processing/input_data')],
outputs=[ProcessingOutput(
source='/opt/ml/processing/processed_data',
destination='')],
)
```
Au lieu de créer votre code de traitement dans votre image de traitement, vous pouvez fournir un `ScriptProcessor` avec votre image et la commande que vous voulez exécuter, ainsi que le code que vous voulez exécuter à l'intérieur de ce conteneur. Pour obtenir un exemple, consultez [Exécuter des scripts avec votre propre conteneur de traitement](processing-container-run-scripts.md).
Vous pouvez également utiliser l'image scikit-learn fournie par Amazon SageMaker Processing `SKLearnProcessor` pour exécuter des scripts scikit-learn. Pour obtenir un exemple, consultez [Exécution d’une tâche de traitement avec scikit-learn](use-scikit-learn-processing-container.md).