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.
# Compilation de modèles avec Neo
Cette section explique comment créer, décrire, arrêter et répertorier les tâches de compilation. Les options suivantes sont disponibles dans Amazon SageMaker Neo pour gérer les tâches de compilation pour les modèles d'apprentissage automatique : la AWS Command Line Interface console Amazon SageMaker AI ou le SageMaker SDK Amazon.
**Topics**
+ [Préparation d'un modèle pour la compilation](neo-compilation-preparing-model.md)
+ [Compilation d'un modèle (AWS Command Line Interface)](neo-job-compilation-cli.md)
+ [Compiler un modèle (Amazon SageMaker AI Console)](neo-job-compilation-console.md)
+ [Compiler un modèle (SDK Amazon SageMaker AI)](neo-job-compilation-sagemaker-sdk.md)
# Préparation d'un modèle pour la compilation
SageMaker Neo a besoin de modèles d'apprentissage automatique pour satisfaire des formes de données d'entrée spécifiques. La forme d'entrée requise pour la compilation dépend du cadre de deep learning que vous utilisez. Une fois votre modèle formaté à la forme d'entrée correcte, enregistrez-le conformément aux exigences ci-dessous. Lorsque vous disposez d'un modèle enregistré, compressez les artefacts du modèle.
**Topics**
+ [Quelles sont les formes de données d'entrée attendues par SageMaker Neo ?](#neo-job-compilation-expected-inputs)
+ [Modèles d'épargne pour SageMaker Neo](#neo-job-compilation-how-to-save-model)
## Quelles sont les formes de données d'entrée attendues par SageMaker Neo ?
Avant de compiler votre modèle, assurez-vous qu'il est correctement formaté. Pour Neo, le nom et la forme des entrées de données pour votre modèle entraîné doivent être au format JSON ou au format liste. Les entrées attendues sont spécifiques au cadre.
Vous trouverez ci-dessous les formes d'entrée attendues par SageMaker Neo :
### Keras
Spécifiez le nom et la forme (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour le modèle entraîné. Notez que si les artefacts du modèle Keras doivent être téléchargés au format NHWC (channel-last), ils DataInputConfig doivent être spécifiés au format NCHW (channel-first). Voici quels sont les formats de dictionnaire requis :
+ Pour une entrée : `{'input_1':[1,3,224,224]}`
+ Pour deux entrées : `{'input_1': [1,3,224,224], 'input_2':[1,3,224,224]}`
### MXNet/ONX
Spécifiez le nom et la forme (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour le modèle entraîné. Voici quels sont les formats de dictionnaire requis :
+ Pour une entrée : `{'data':[1,3,1024,1024]}`
+ Pour deux entrées : `{'var1': [1,1,28,28], 'var2':[1,1,28,28]}`
### PyTorch
Pour un PyTorch modèle, il n'est pas nécessaire de fournir le nom et la forme des entrées de données attendues si vous remplissez les deux conditions suivantes :
+ Vous avez créé votre fichier de définition de modèle à l'aide de la PyTorch version 2.0 ou ultérieure. Pour plus d'informations sur la création du fichier de définition, consultez la [PyTorch](#how-to-save-pytorch) section intitulée *Enregistrer des modèles pour SageMaker Neo*.
+ Vous compilez votre modèle pour une instance cloud. Pour plus d'informations sur les types d'instances pris en charge par SageMaker Neo, consultez[Cadres et types d’instance pris en charge](neo-supported-cloud.md).
Si vous remplissez ces conditions, SageMaker Neo obtient la configuration d'entrée à partir du fichier de définition du modèle (.pt ou .pth) que vous créez avec. PyTorch
Sinon, vous devez exécuter les actions suivantes :
Spécifiez le nom et la forme (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour le modèle entraîné. Vous pouvez aussi spécifier la forme en utilisant uniquement un format liste. Voici quels sont les formats de dictionnaire requis :
+ Pour une entrée au format dictionnaire : `{'input0':[1,3,224,224]}`
+ Pour une entrée au format liste : `[[1,3,224,224]]`
+ Pour deux entrées au format dictionnaire : `{'input0':[1,3,224,224], 'input1':[1,3,224,224]}`
+ Pour deux entrées au format liste : `[[1,3,224,224], [1,3,224,224]]`
### TensorFlow
Spécifiez le nom et la forme (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour votre modèle entraîné. Voici quels sont les formats de dictionnaire requis :
+ Pour une entrée : `{'input':[1,1024,1024,3]}`
+ Pour deux entrées : `{'data1': [1,28,28,1], 'data2':[1,28,28,1]}`
### TFLite
Spécifiez le nom et la forme (format NHWC) des entrées de données attendues en utilisant un format dictionnaire pour votre modèle entraîné. Voici quels sont les formats de dictionnaire requis :
+ Pour une entrée : `{'input':[1,224,224,3]}`
**Note**
SageMaker Neo prend uniquement en charge la version TensorFlow Lite pour les cibles périphériques. Pour obtenir la liste des appareils cibles SageMaker Neo Edge compatibles, consultez la [Appareils](neo-supported-devices-edge-devices.md#neo-supported-edge-devices) page SageMaker Neo. Pour obtenir la liste des cibles d'instances cloud SageMaker Neo prises en charge, consultez la [Cadres et types d’instance pris en charge](neo-supported-cloud.md) page SageMaker Neo.
### XGBoost
Le nom et la forme des données d'entrée ne sont pas nécessaires.
## Modèles d'épargne pour SageMaker Neo
Les exemples de code suivants montrent comment enregistrer votre modèle pour le rendre compatible avec Neo. Les modèles doivent être packagés sous forme de fichiers tar compressés (`*.tar.gz`).
### Keras
Les modèles Keras ont besoin d'un fichier de définition de modèle (`.h5`).
Il existe deux options pour enregistrer votre modèle Keras afin de le rendre compatible avec SageMaker Neo :
1. Exporter au format `.h5` avec `model.save("", save_format="h5")`.
1. Figer le `SavedModel` après l'exportation.
Voici un exemple d'exportation d'un modèle `tf.keras` sous forme de graphique figé (option deux) :
```
import os
import tensorflow as tf
from tensorflow.keras.applications.resnet50 import ResNet50
from tensorflow.keras import backend
tf.keras.backend.set_learning_phase(0)
model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3), pooling='avg')
model.summary()
# Save as a SavedModel
export_dir = 'saved_model/'
model.save(export_dir, save_format='tf')
# Freeze saved model
input_node_names = [inp.name.split(":")[0] for inp in model.inputs]
output_node_names = [output.name.split(":")[0] for output in model.outputs]
print("Input names: ", input_node_names)
with tf.Session() as sess:
loaded = tf.saved_model.load(sess, export_dir=export_dir, tags=["serve"])
frozen_graph = tf.graph_util.convert_variables_to_constants(sess,
sess.graph.as_graph_def(),
output_node_names)
tf.io.write_graph(graph_or_graph_def=frozen_graph, logdir=".", name="frozen_graph.pb", as_text=False)
import tarfile
tar = tarfile.open("frozen_graph.tar.gz", "w:gz")
tar.add("frozen_graph.pb")
tar.close()
```
**Avertissement**
N'exportez pas votre modèle avec la classe `SavedModel` en utilisant `model.save(, save_format='tf')`. Ce format convient à l'entraînement, mais pas à l'inférence.
### MXNet
MXNet les modèles doivent être enregistrés sous la forme d'un fichier de symboles unique `*-symbol.json` et d'un seul paramètre`*.params files`.
------
#### [ Gluon Models ]
Définissez le réseau neuronal à l'aide de la classe `HybridSequential`. Le code s'exécutera dans le style d'une programmation symbolique (par opposition à une programmation impérative).
```
from mxnet import nd, sym
from mxnet.gluon import nn
def get_net():
net = nn.HybridSequential() # Here we use the class HybridSequential.
net.add(nn.Dense(256, activation='relu'),
nn.Dense(128, activation='relu'),
nn.Dense(2))
net.initialize()
return net
# Define an input to compute a forward calculation.
x = nd.random.normal(shape=(1, 512))
net = get_net()
# During the forward calculation, the neural network will automatically infer
# the shape of the weight parameters of all the layers based on the shape of
# the input.
net(x)
# hybridize model
net.hybridize()
net(x)
# export model
net.export('') # this will create model-symbol.json and model-0000.params files
import tarfile
tar = tarfile.open(".tar.gz", "w:gz")
for name in ["-0000.params", "-symbol.json"]:
tar.add(name)
tar.close()
```
Pour plus d'informations sur les modèles d'hybridation, consultez la documentation d'[MXNet hybridation](https://mxnet.apache.org/versions/1.7.0/api/python/docs/tutorials/packages/gluon/blocks/hybridize.html).
------
#### [ Gluon Model Zoo (GluonCV) ]
Les modèles de zoo GluonCV sont pré-hybridés. Vous pouvez donc simplement les exporter.
```
import numpy as np
import mxnet as mx
import gluoncv as gcv
from gluoncv.utils import export_block
import tarfile
net = gcv.model_zoo.get_model('', pretrained=True) # For example, choose as resnet18_v1
export_block('', net, preprocess=True, layout='HWC')
tar = tarfile.open(".tar.gz", "w:gz")
for name in ["-0000.params", "-symbol.json"]:
tar.add(name)
tar.close()
```
------
#### [ Non Gluon Models ]
Lorsque les modèles sans gluon sont enregistrés sur disque, ils utilisent tous des fichiers `*-symbol` et `*.params`fichiers. Ils sont donc déjà au bon format pour Neo.
```
# Pass the following 3 parameters: sym, args, aux
mx.model.save_checkpoint('',0,sym,args,aux) # this will create -symbol.json and -0000.params files
import tarfile
tar = tarfile.open(".tar.gz", "w:gz")
for name in ["-0000.params", "-symbol.json"]:
tar.add(name)
tar.close()
```
------
### PyTorch
PyTorch les modèles doivent être enregistrés sous forme de fichier de définition (`.pt`ou`.pth`) avec le type de données d'entrée de. `float32`
Pour enregistrer votre modèle, utilisez la méthode `torch.jit.trace` suivie de la méthode `torch.save`. Ce processus enregistre un objet dans un fichier disque et utilise par défaut le module pickle (`pickle_module=pickle`) Python pour enregistrer les objets et certaines métadonnées. Ensuite, convertissez le modèle enregistré en un fichier tar compressé.
```
import torchvision
import torch
model = torchvision.models.resnet18(pretrained=True)
model.eval()
inp = torch.rand(1, 3, 224, 224)
model_trace = torch.jit.trace(model, inp)
# Save your model. The following code saves it with the .pth file extension
model_trace.save('model.pth')
# Save as a compressed tar file
import tarfile
with tarfile.open('model.tar.gz', 'w:gz') as f:
f.add('model.pth')
f.close()
```
Si vous enregistrez votre modèle avec la PyTorch version 2.0 ou une version ultérieure, SageMaker Neo déduit la configuration d'entrée du modèle (le nom et la forme de son entrée) à partir du fichier de définition. Dans ce cas, il n'est pas nécessaire de spécifier la configuration d'entrée de données à l' SageMaker IA lorsque vous compilez le modèle.
Si vous souhaitez empêcher SageMaker Neo de dériver la configuration d'entrée, vous pouvez définir le `_store_inputs` paramètre `torch.jit.trace` to`False`. Dans ce cas, vous devez spécifier la configuration d'entrée de données à l' SageMaker IA lorsque vous compilez le modèle.
Pour plus d'informations sur la `torch.jit.trace` méthode, consultez [TORCH.JIT.TRACE](https://pytorch.org/docs/stable/generated/torch.jit.trace.html#torch.jit.trace) dans la documentation. PyTorch
### TensorFlow
TensorFlow nécessite un `.pb` ou un `.pbtxt` fichier et un répertoire de variables contenant des variables. Pour les modèles figés, un seul fichier `.pb` ou `.pbtxt` est nécessaire.
L'exemple de code suivant montre comment compresser votre modèle à l'aide de la commande tar Linux. Exécutez les opérations suivantes sur votre terminal ou dans un bloc-notes Jupyter (si vous utilisez un bloc-notes Jupyter, insérez la commande magique `!`au début de l'énoncé) :
```
# Download SSD_Mobilenet trained model
!wget http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v2_coco_2018_03_29.tar.gz
# unzip the compressed tar file
!tar xvf ssd_mobilenet_v2_coco_2018_03_29.tar.gz
# Compress the tar file and save it in a directory called 'model.tar.gz'
!tar czvf model.tar.gz ssd_mobilenet_v2_coco_2018_03_29/frozen_inference_graph.pb
```
Les indicateurs de commande utilisés dans cet exemple accomplissent les tâches suivantes :
+ `c` : création d'une archive
+ `z` : compression de l'archive avec gzip
+ `v` : affichage de la progression de l'archive
+ `f` : spécification du nom de fichier de l'archive
### Estimateurs intégrés
Les estimateurs intégrés sont réalisés par des conteneurs spécifiques au cadre ou des conteneurs spécifiques à l'algorithme. Les objets d'estimateurs intégrés spécifiques à l'algorithme et au cadre enregistrent le modèle au format correct pour vous lorsque vous entraînez le modèle à l'aide de la méthode intégrée `.fit`.
Par exemple, vous pouvez utiliser a `sagemaker.TensorFlow` pour définir un TensorFlow estimateur :
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(entry_point='mnist.py',
role=role, #param role can be arn of a sagemaker execution role
framework_version='1.15.3',
py_version='py3',
training_steps=1000,
evaluation_steps=100,
instance_count=2,
instance_type='ml.c4.xlarge')
```
Ensuite, entraînez le modèle avec la méthode intégrée `.fit` :
```
estimator.fit(inputs)
```
Avant de terminer la compilation du modèle avec la méthode intégrée `compile_model` :
```
# Specify output path of the compiled model
output_path = '/'.join(estimator.output_path.split('/')[:-1])
# Compile model
optimized_estimator = estimator.compile_model(target_instance_family='ml_c5',
input_shape={'data':[1, 784]}, # Batch size 1, 3 channels, 224x224 Images.
output_path=output_path,
framework='tensorflow', framework_version='1.15.3')
```
Vous pouvez également utiliser la `sagemaker.estimator.Estimator` classe pour initialiser un objet estimateur afin d'entraîner et de compiler un algorithme intégré avec la méthode `compile_model` du SDK Python : SageMaker
```
import sagemaker
from sagemaker.image_uris import retrieve
sagemaker_session = sagemaker.Session()
aws_region = sagemaker_session.boto_region_name
# Specify built-in algorithm training image
training_image = retrieve(framework='image-classification',
region=aws_region, image_scope='training')
training_image = retrieve(framework='image-classification', region=aws_region, image_scope='training')
# Create estimator object for training
estimator = sagemaker.estimator.Estimator(image_uri=training_image,
role=role, #param role can be arn of a sagemaker execution role
instance_count=1,
instance_type='ml.p3.8xlarge',
volume_size = 50,
max_run = 360000,
input_mode= 'File',
output_path=s3_training_output_location,
base_job_name='image-classification-training'
)
# Setup the input data_channels to be used later for training.
train_data = sagemaker.inputs.TrainingInput(s3_training_data_location,
content_type='application/x-recordio',
s3_data_type='S3Prefix')
validation_data = sagemaker.inputs.TrainingInput(s3_validation_data_location,
content_type='application/x-recordio',
s3_data_type='S3Prefix')
data_channels = {'train': train_data, 'validation': validation_data}
# Train model
estimator.fit(inputs=data_channels, logs=True)
# Compile model with Neo
optimized_estimator = estimator.compile_model(target_instance_family='ml_c5',
input_shape={'data':[1, 3, 224, 224], 'softmax_label':[1]},
output_path=s3_compilation_output_location,
framework='mxnet',
framework_version='1.7')
```
Pour plus d'informations sur la compilation de modèles avec le SDK SageMaker Python, consultez. [Compiler un modèle (SDK Amazon SageMaker AI)](neo-job-compilation-sagemaker-sdk.md)
# Compilation d'un modèle (AWS Command Line Interface)
Cette section explique comment gérer les tâches de compilation Amazon SageMaker Neo pour les modèles d'apprentissage automatique à l'aide de AWS Command Line Interface (CLI). Vous pouvez créer, décrire, arrêter et répertorier les tâches de compilation.
1. Créez une tâche de compilation
Grâce à l'opération [CreateCompilationJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateCompilationJob.html)API, vous pouvez spécifier le format d'entrée des données, le compartiment S3 dans lequel stocker votre modèle, le compartiment S3 dans lequel écrire le modèle compilé et le périphérique ou la plate-forme matérielle cible.
Le tableau suivant montre comment configurer l'API `CreateCompilationJob` selon que votre cible est un périphérique ou une plateforme.
------
#### [ Device Example ]
```
{
"CompilationJobName": "neo-compilation-job-demo",
"RoleArn": "arn:aws:iam:::role/service-role/AmazonSageMaker-ExecutionRole-yyyymmddThhmmss",
"InputConfig": {
"S3Uri": "s3:///sagemaker/neo-compilation-job-demo-data/train",
"DataInputConfig": "{'data': [1,3,1024,1024]}",
"Framework": "MXNET"
},
"OutputConfig": {
"S3OutputLocation": "s3:///sagemaker/neo-compilation-job-demo-data/compile",
# A target device specification example for a ml_c5 instance family
"TargetDevice": "ml_c5"
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 300
}
}
```
Vous pouvez éventuellement spécifier la version du framework que vous avez utilisée avec le [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InputConfig.html#sagemaker-Type-InputConfig-FrameworkVersion](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InputConfig.html#sagemaker-Type-InputConfig-FrameworkVersion)champ si vous avez utilisé le PyTorch framework pour entraîner votre modèle et que votre équipement cible est une `ml_* ` cible.
```
{
"CompilationJobName": "neo-compilation-job-demo",
"RoleArn": "arn:aws:iam:::role/service-role/AmazonSageMaker-ExecutionRole-yyyymmddThhmmss",
"InputConfig": {
"S3Uri": "s3:///sagemaker/neo-compilation-job-demo-data/train",
"DataInputConfig": "{'data': [1,3,1024,1024]}",
"Framework": "PYTORCH",
"FrameworkVersion": "1.6"
},
"OutputConfig": {
"S3OutputLocation": "s3:///sagemaker/neo-compilation-job-demo-data/compile",
# A target device specification example for a ml_c5 instance family
"TargetDevice": "ml_c5",
# When compiling for ml_* instances using PyTorch framework, use the "CompilerOptions" field in
# OutputConfig to provide the correct data type ("dtype") of the model’s input. Default assumed is "float32"
"CompilerOptions": "{'dtype': 'long'}"
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 300
}
}
```
**Remarques :**
Si vous avez enregistré votre modèle à l'aide de PyTorch la version 2.0 ou ultérieure, le `DataInputConfig` champ est facultatif. SageMaker AI Neo obtient la configuration d'entrée à partir du fichier de définition du modèle que vous créez avec PyTorch. Pour plus d'informations sur la création du fichier de définition, consultez la [PyTorch](neo-compilation-preparing-model.md#how-to-save-pytorch) section intitulée *Enregistrer des modèles pour SageMaker AI Neo*.
Ce champ d'API n'est pris en charge que pour PyTorch.
------
#### [ Platform Example ]
```
{
"CompilationJobName": "neo-test-compilation-job",
"RoleArn": "arn:aws:iam:::role/service-role/AmazonSageMaker-ExecutionRole-yyyymmddThhmmss",
"InputConfig": {
"S3Uri": "s3:///sagemaker/neo-compilation-job-demo-data/train",
"DataInputConfig": "{'data': [1,3,1024,1024]}",
"Framework": "MXNET"
},
"OutputConfig": {
"S3OutputLocation": "s3:///sagemaker/neo-compilation-job-demo-data/compile",
# A target platform configuration example for a p3.2xlarge instance
"TargetPlatform": {
"Os": "LINUX",
"Arch": "X86_64",
"Accelerator": "NVIDIA"
},
"CompilerOptions": "{'cuda-ver': '10.0', 'trt-ver': '6.0.1', 'gpu-code': 'sm_70'}"
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 300
}
}
```
------
**Note**
Pour l'opération d'API `OutputConfig`, les opérations d'API `TargetDevice` et `TargetPlatform` s'excluent mutuellement. Vous devez choisir l'une de ces deux options.
Pour trouver les exemples de chaînes JSON de `DataInputConfig` en fonction des cadres, consultez [De quelles formes de données d’entrée Neo a-t-il besoin ?](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting-compilation.html#neo-troubleshooting-errors-preventing).
Pour plus d'informations sur la configuration des configurations, consultez les opérations [InputConfig[OutputConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputConfig.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InputConfig.html), et [TargetPlatform](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TargetPlatform.html)d'API dans la référence des SageMaker API.
1. Après avoir configuré le fichier JSON, exécutez la commande suivante pour créer la tâche de compilation :
```
aws sagemaker create-compilation-job \
--cli-input-json file://job.json \
--region us-west-2
# You should get CompilationJobArn
```
1. Décrivez la tâche de compilation en exécutant la commande suivante :
```
aws sagemaker describe-compilation-job \
--compilation-job-name $JOB_NM \
--region us-west-2
```
1. Arrêtez la tâche de compilation en exécutant la commande suivante :
```
aws sagemaker stop-compilation-job \
--compilation-job-name $JOB_NM \
--region us-west-2
# There is no output for compilation-job operation
```
1. Répertoriez la tâche de compilation en exécutant la commande suivante :
```
aws sagemaker list-compilation-jobs \
--region us-west-2
```
# Compiler un modèle (Amazon SageMaker AI Console)
Vous pouvez créer une tâche de compilation Amazon SageMaker Neo dans la console Amazon SageMaker AI.
1. Dans la console **Amazon SageMaker AI**, choisissez **Compilation jobs**, puis **Create compilation job**.
![\[Crée une tâche de compilation.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/8-create-compilation-job.png)
1. Sur la page **Create compilation job (Créer une tâche de compilation)**, pour **Job name (Nom de la tâche)**, saisissez un nom. Ensuite, sélectionnez un **rôle IAM**.
![\[Page Créer une tâche de compilation.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/9-create-compilation-job-config.png)
1. Si vous ne disposez pas de rôle IAM, choisissez **Créer un rôle**.
![\[Créez un emplacement de rôle IAM.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/10a-create-iam-role.png)
1. Sur la page **Créer un rôle IAM**, choisissez **Tout compartiment S3**, puis **Créer un rôle**.
![\[Page Créer un rôle IAM.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/10-create-iam-role.png)
1.
------
#### [ Non PyTorch Frameworks ]
Dans la section **Input configuration (Configuration d'entrée)**, saisissez le chemin d'accès complet de l'URI du compartiment Amazon S3 contenant vos artefacts de modèle, dans le champ d'entrée **Location of model artifacts (Emplacement des artefacts de modèle)**. Vos artefacts de modèle doivent être au format de fichier tarball compressé (`.tar.gz`).
Dans le champ **Data input configuration (Configuration d'entrée de données)**, saisissez la chaîne JSON qui spécifie la forme des données d'entrée.
Pour **Machine learning framework (Cadre de machine learning)**, choisissez le cadre qui vous convient.
![\[Page Configuration d’entrée.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/neo-create-compilation-job-input-config.png)
Pour trouver les exemples de chaînes JSON de formes de données d’entrée spécifiques aux cadres, consultez [De quelles formes de données d’entrée Neo a-t-il besoin ?](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting.html#neo-troubleshooting-errors-preventing).
------
#### [ PyTorch Framework ]
Des instructions similaires s'appliquent à la compilation des PyTorch modèles. Toutefois, si vous vous êtes entraîné avec le modèle cible PyTorch et que vous essayez de le compiler pour `ml_*` (sauf`ml_inf`), vous pouvez éventuellement spécifier la version PyTorch que vous avez utilisée.
![\[Exemple illustrant la section Configuration d’entrée indiquant où choisir la version du cadre.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/compile_console_pytorch.png)
Pour trouver les exemples de chaînes JSON de formes de données d’entrée spécifiques aux cadres, consultez [De quelles formes de données d’entrée Neo a-t-il besoin ?](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting.html#neo-troubleshooting-errors-preventing).
**Remarques**
Si vous avez enregistré votre modèle à l'aide de PyTorch la version 2.0 ou ultérieure, le **champ Configuration de la saisie des données** est facultatif. SageMaker Neo obtient la configuration d'entrée à partir du fichier de définition du modèle que vous créez avec PyTorch. Pour plus d'informations sur la création du fichier de définition, consultez la [PyTorch](neo-compilation-preparing-model.md#how-to-save-pytorch) section intitulée *Enregistrer des modèles pour SageMaker AI Neo*.
Lors de la compilation pour des `ml_*` instances à l'aide du PyTorch framework, utilisez le champ **d'options du compilateur** dans la **configuration de sortie** pour fournir le type de données correct (`dtype`) de l'entrée du modèle. La valeur par défaut est définie sur `"float32"`.
![\[Exemple illustrant la section Configuration de sortie.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/neo_compilation_console_pytorch_compiler_options.png)
**Avertissement**
Si vous spécifiez un chemin d'URI de compartiment Amazon S3 menant à un fichier `.pth`, l'erreur suivante s'affichera après que la compilation aura démarré : `ClientError: InputConfiguration: Unable to untar input model.Please confirm the model is a tar.gz file`
------
1. Accédez à la section **Output configuration (Configuration de la sortie)**. Choisissez l'emplacement de déploiement de votre modèle. Vous pouvez déployer votre modèle sur un **périphérique cible** ou une **plateforme cible**. Les périphériques cibles comprennent les périphériques cloud et en périphérie. Les plateformes cibles font référence au système d'exploitation, à l'architecture et aux accélérateurs spécifiques sur lesquels votre modèle doit s'exécuter.
Pour **S3 Output location (Emplacement de sortie S3)**, saisissez le chemin d'accès au compartiment S3 où vous voulez stocker le modèle compilé. Vous pouvez éventuellement ajouter des options de compilateur au format JSON dans la section **Compiler options (Options de compilateur)**.
![\[Page Configuration de sortie.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/neo-console-output-config.png)
1. Vérifiez le statut de la tâche de compilation au démarrage. Le statut de la tâche se trouve en haut de la page **Compilation Job (Tâche de compilation)** comme le montre la capture d'écran ci-après. Vous pouvez également vérifier le statut de la tâche dans la colonne **Status (Statut)**.
![\[Statut de la tâche de compilation.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/12-run-model-compilation.png)
1. Vérifiez le statut de la tâche de compilation lorsque terminée. Vous pouvez vérifier le statut dans la colonne **Status (Statut)** comme le montre la capture d'écran ci-après.
![\[Statut de la tâche de compilation.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/neo/12a-completed-model-compilation.png)
# Compiler un modèle (SDK Amazon SageMaker AI)
Vous pouvez utiliser l'[https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html?#sagemaker.estimator.Estimator.compile_model](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html?#sagemaker.estimator.Estimator.compile_model)API du [SDK Amazon SageMaker AI pour Python](https://sagemaker.readthedocs.io/en/stable/) afin de compiler un modèle entraîné et de l'optimiser pour un matériel cible spécifique. L'API doit être appelée sur l'objet estimateur utilisé pendant l'entraînement du modèle.
**Note**
Vous devez définir la variable d'`MMS_DEFAULT_RESPONSE_TIMEOUT`environnement sur `500` lorsque vous compilez le modèle avec MXNet ou PyTorch. La variable d'environnement n'est pas nécessaire pour TensorFlow.
Voici un exemple de la façon dont vous pouvez compiler un modèle à l'aide de l'objet `trained_model_estimator` :
```
# Replace the value of expected_trained_model_input below and
# specify the name & shape of the expected inputs for your trained model
# in json dictionary form
expected_trained_model_input = {'data':[1, 784]}
# Replace the example target_instance_family below to your preferred target_instance_family
compiled_model = trained_model_estimator.compile_model(target_instance_family='ml_c5',
input_shape=expected_trained_model_input,
output_path='insert s3 output path',
env={'MMS_DEFAULT_RESPONSE_TIMEOUT': '500'})
```
Le code compile le modèle, enregistre le modèle optimisé dans et crée un modèle d' SageMaker IA qui peut être déployé sur un point de terminaison. `output_path`