Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Compilación de modelos con Neo
En esta sección se muestra cómo crear, describir, detener y generar una lista de trabajos de compilación. Las siguientes opciones están disponibles en Amazon SageMaker Neo para gestionar los trabajos de compilación de los modelos de aprendizaje automático: la AWS Command Line Interface consola Amazon SageMaker AI o el Amazon SageMaker SDK.
**Topics**
+ [Preparación del modelo para compilación](neo-compilation-preparing-model.md)
+ [Compilación de un modelo (AWS Command Line Interface)](neo-job-compilation-cli.md)
+ [Compilar un modelo (Amazon SageMaker AI Console)](neo-job-compilation-console.md)
+ [Compilar un modelo (Amazon SageMaker AI SDK)](neo-job-compilation-sagemaker-sdk.md)
# Preparación del modelo para compilación
SageMaker Neo requiere que los modelos de aprendizaje automático se adapten a formas de datos de entrada específicas. La forma de entrada necesaria para la compilación depende del marco de aprendizaje profundo que utilice. Una vez que la forma de entrada del modelo tenga el formato correcto, guarde el modelo de acuerdo con los requisitos que se indican a continuación. Una vez que haya guardado el modelo, comprima los artefactos del modelo.
**Topics**
+ [¿Qué formas de datos de entrada espera SageMaker Neo?](#neo-job-compilation-expected-inputs)
+ [Guardar modelos para SageMaker Neo](#neo-job-compilation-how-to-save-model)
## ¿Qué formas de datos de entrada espera SageMaker Neo?
Antes de compilar el modelo, asegúrese de que tiene el formato correcto. Neo espera el nombre y la forma de las entradas de datos previstas para su modelo formado con formato de diccionario JSON o formato de lista. Las entradas de datos previstas son específicas del marco.
A continuación se muestran las formas de entrada que SageMaker Neo espera:
### Keras
Especifique el nombre y la forma (formato NCHW) de las entradas de datos previstas usando un formato de diccionario para su modelo entrenado. Tenga en cuenta que, si bien los artefactos del modelo Keras deben cargarse en formato NHWC (último canal), DataInputConfig deben especificarse en formato NCHW (canal primero). Los formatos de diccionario necesarios son los siguientes:
+ Para una entrada: `{'input_1':[1,3,224,224]}`
+ Para dos entradas: `{'input_1': [1,3,224,224], 'input_2':[1,3,224,224]}`
### MXNet/ONNX
Especifique el nombre y la forma (formato NCHW) de las entradas de datos previstas usando un formato de diccionario para su modelo entrenado. Los formatos de diccionario necesarios son los siguientes:
+ Para una entrada: `{'data':[1,3,1024,1024]}`
+ Para dos entradas: `{'var1': [1,1,28,28], 'var2':[1,1,28,28]}`
### PyTorch
En el caso de un PyTorch modelo, no es necesario proporcionar el nombre y la forma de las entradas de datos esperadas si se cumplen las dos condiciones siguientes:
+ Creó el archivo de definición del modelo con la PyTorch versión 2.0 o una versión posterior. Para obtener más información sobre cómo crear el archivo de definición, consulte la [PyTorch](#how-to-save-pytorch) sección sobre cómo *guardar modelos para SageMaker Neo*.
+ Está compilando el modelo para una instancia en la nube. Para obtener más información sobre los tipos de instancias compatibles con SageMaker Neo, consulte[Tipos de instancias y marcos compatibles](neo-supported-cloud.md).
Si cumples estas condiciones, SageMaker Neo obtiene la configuración de entrada del archivo de definición del modelo (.pt o .pth) con el que hayas creado. PyTorch
De lo contrario, tendrá que hacer lo siguiente:
Especifique el nombre y la forma (formato NCHW) de las entradas de datos previstas usando un formato de diccionario para su modelo entrenado. Como alternativa, puede especificar la forma únicamente mediante un formato de lista. Los formatos de diccionario necesarios son los siguientes:
+ Para una entrada en formato de diccionario: `{'input0':[1,3,224,224]}`
+ Para una entrada en formato de lista: `[[1,3,224,224]]`
+ Para dos entradas en formato de diccionario: `{'input0':[1,3,224,224], 'input1':[1,3,224,224]}`
+ Para dos entradas en formato de lista: `[[1,3,224,224], [1,3,224,224]]`
### TensorFlow
Especifique el nombre y la forma (formato NHWC) de las entradas de datos previstas usando un formato de diccionario para su modelo entrenado. Los formatos de diccionario necesarios son los siguientes:
+ Para una entrada: `{'input':[1,1024,1024,3]}`
+ Para dos entradas: `{'data1': [1,28,28,1], 'data2':[1,28,28,1]}`
### TFLite
Especifique el nombre y la forma (formato NHWC) de las entradas de datos previstas usando un formato de diccionario para su modelo entrenado. Los formatos de diccionario necesarios son los siguientes:
+ Para una entrada: `{'input':[1,224,224,3]}`
**nota**
SageMaker Neo solo es compatible con TensorFlow Lite para dispositivos periféricos. Para obtener una lista de los dispositivos SageMaker Neo edge compatibles, consulta la [Dispositivos](neo-supported-devices-edge-devices.md#neo-supported-edge-devices) página de SageMaker Neo. Para ver una lista de los destinos de instancias en la nube de SageMaker Neo compatibles, consulta la [Tipos de instancias y marcos compatibles](neo-supported-cloud.md) página de SageMaker Neo.
### XGBoost
No son necesarios el nombre y la forma de los datos de entrada.
## Guardar modelos para SageMaker Neo
En los siguientes ejemplos de código se muestra cómo guardar el modelo para que sea compatible con Neo. Los modelos deben empaquetarse como archivos tar comprimidos (`*.tar.gz`).
### Keras
Los modelos de Keras requieren un archivo de definición de modelo (`.h5`).
Hay dos opciones para guardar tu modelo Keras y hacerlo compatible con SageMaker Neo:
1. Exporte a formato `.h5` con `model.save("", save_format="h5")`.
1. Congele el archivo `SavedModel` después de exportarlo.
A continuación se muestra un ejemplo de cómo exportar un modelo `tf.keras` como un gráfico congelado (segunda opción):
```
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()
```
**aviso**
No exporte su modelo con clase `SavedModel` utilizando `model.save(, save_format='tf')`. Este formato es adecuado para el entrenamiento, pero no para la inferencia.
### MXNet
MXNet los modelos se deben guardar como un único archivo de símbolos `*-symbol.json` y un único parámetro`*.params files`.
------
#### [ Gluon Models ]
Defina la red neuronal mediante la Clase `HybridSequential`. Esto ejecutará el código al estilo de programación simbólica (a diferencia de programación imperativa).
```
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()
```
Para obtener más información sobre la hibridación de modelos, consulte la documentación sobre la [MXNet hibridación](https://mxnet.apache.org/versions/1.7.0/api/python/docs/tutorials/packages/gluon/blocks/hybridize.html).
------
#### [ Gluon Model Zoo (GluonCV) ]
Los modelos de zoológico modelo GluonCV vienen prehibridados. Así que puede simplemente exportarlos.
```
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 ]
Todos los modelos que no son Gluon cuando se guardan en disco utilizan archivos `*-symbol` y `*.params`. Por lo tanto, ya están en el formato correcto para 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 los modelos deben guardarse como un archivo de definición (`.pt`o`.pth`) con un tipo de datos de entrada de. `float32`
Para guardar el modelo, utilice el método `torch.jit.trace` seguido del método `torch.save`. Este proceso guarda un objeto en un archivo de disco y, de forma predeterminada, usa python pickle (`pickle_module=pickle`) para guardar los objetos y algunos metadatos. A continuación, convierte el modelo guardado en un archivo tar comprimido.
```
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 guarda el modelo con la PyTorch versión 2.0 o posterior, SageMaker Neo obtiene la configuración de entrada del modelo (el nombre y la forma de su entrada) del archivo de definición. En ese caso, no es necesario especificar la configuración de entrada de datos para SageMaker AI al compilar el modelo.
Si quieres evitar que SageMaker Neo obtenga la configuración de entrada, puedes establecer el `_store_inputs` parámetro en. `torch.jit.trace` `False` Si lo hace, debe especificar la configuración de entrada de datos para SageMaker AI al compilar el modelo.
Para obtener más información sobre el `torch.jit.trace` método, consulte [TORCH.JIT.TRACE](https://pytorch.org/docs/stable/generated/torch.jit.trace.html#torch.jit.trace) en la documentación. PyTorch
### TensorFlow
TensorFlow requiere uno `.pb` o un `.pbtxt` archivo y un directorio de variables que contenga variables. Para modelos congelados, solo se necesita un archivo `.pb` o `.pbtxt`.
En el siguiente ejemplo de código se muestra cómo utilizar el comando tar de Linux para comprimir el modelo. Ejecute lo siguiente en su terminal o en un cuaderno de Jupyter (si utiliza un cuaderno de Jupyter, inserte el comando mágico `!` al principio de la instrucción):
```
# 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
```
Los indicadores de comando utilizados en este ejemplo permiten lo siguiente:
+ `c`: crear un archivo
+ `z`: comprimir el archivo con gzip
+ `v`: mostrar el avance del archivo
+ `f`: especificar el nombre del archivo
### Estimadores integrados
Los estimadores integrados se crean mediante contenedores específicos del marco o contenedores específicos de un algoritmo. Los objetos del estimador, tanto para el algoritmo integrado como para el estimador específico del marco, guardan el modelo en el formato correcto cuando se entrena el modelo con el método integrado `.fit`.
Por ejemplo, puede usar `sagemaker.TensorFlow` a para definir un TensorFlow estimador:
```
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')
```
Luego forme al modelo con el método incorporado `.fit`:
```
estimator.fit(inputs)
```
Antes de compilar por último el modelo con el método incorporado `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')
```
También puedes usar la `sagemaker.estimator.Estimator` clase para inicializar un objeto estimador para entrenar y compilar un algoritmo integrado con el método del SDK `compile_model` de 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')
```
Para obtener más información sobre la compilación de modelos con el SDK de SageMaker Python, consulte[Compilar un modelo (Amazon SageMaker AI SDK)](neo-job-compilation-sagemaker-sdk.md).
# Compilación de un modelo (AWS Command Line Interface)
En esta sección se muestra cómo gestionar los trabajos de compilación de Amazon SageMaker Neo para modelos de aprendizaje automático mediante AWS Command Line Interface (CLI). Puede crear, describir, detener y generar una lista de los trabajos de compilación.
1. Crear un trabajo de compilación
Con la operación de la [CreateCompilationJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateCompilationJob.html)API, puede especificar el formato de entrada de datos, el depósito de S3 en el que almacenar el modelo, el depósito de S3 en el que se escribirá el modelo compilado y el dispositivo o plataforma de hardware de destino.
En la siguiente tabla se muestra cómo configurar la API `CreateCompilationJob` en función de si el objetivo es un dispositivo o una plataforma.
------
#### [ 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
}
}
```
Si lo ha utilizado para entrenar su modelo y su dispositivo de destino es un `ml_* ` objetivo, también puede especificar la versión del PyTorch marco que utilizó con el [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)campo.
```
{
"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
}
}
```
**Notas:**
Si guardó el modelo con la PyTorch versión 2.0 o posterior, el `DataInputConfig` campo es opcional. SageMaker AI Neo obtiene la configuración de entrada del archivo de definición del modelo con el que se crea PyTorch. Para obtener más información sobre cómo crear el archivo de definición, consulte la [PyTorch](neo-compilation-preparing-model.md#how-to-save-pytorch) sección sobre cómo *guardar modelos para SageMaker AI Neo*.
Este campo de API solo es compatible con 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
}
}
```
------
**nota**
Para el funcionamiento de la API `OutputConfig`, las operaciones de la API `TargetDevice` y `TargetPlatform` se excluyen mutuamente. Debe elegir una de las dos opciones.
Para ver ejemplos de cadenas JSON de `DataInputConfig` que dependen de marcos, consulte [Qué formas de datos de entrada espera Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting-compilation.html#neo-troubleshooting-errors-preventing).
Para obtener más información sobre cómo configurar las configuraciones, consulta las operaciones de la [InputConfig[TargetPlatform](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TargetPlatform.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InputConfig.html)API y las operaciones de la API en la referencia de la SageMaker API. [OutputConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputConfig.html)
1. Tras configurar el archivo JSON, ejecute el siguiente comando para crear el trabajo de compilación:
```
aws sagemaker create-compilation-job \
--cli-input-json file://job.json \
--region us-west-2
# You should get CompilationJobArn
```
1. Describa el trabajo de compilación ejecutando el siguiente comando:
```
aws sagemaker describe-compilation-job \
--compilation-job-name $JOB_NM \
--region us-west-2
```
1. Detenga el trabajo de compilación ejecutando el siguiente comando:
```
aws sagemaker stop-compilation-job \
--compilation-job-name $JOB_NM \
--region us-west-2
# There is no output for compilation-job operation
```
1. Enumere el trabajo de compilación ejecutando el siguiente comando:
```
aws sagemaker list-compilation-jobs \
--region us-west-2
```
# Compilar un modelo (Amazon SageMaker AI Console)
Puede crear un trabajo de compilación de Amazon SageMaker Neo en la consola Amazon SageMaker AI.
1. En la consola de **Amazon SageMaker AI**, selecciona **Trabajos de compilación** y, a continuación, selecciona **Crear trabajo de compilación**.
![\[Crear un trabajo de compilación.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/8-create-compilation-job.png)
1. En la página **Crear trabajo de compilación**, en **Nombre de trabajo**, escriba un nombre. Después seleccione un **rol de IAM**.
![\[Página Crear trabajo de compilación\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/9-create-compilation-job-config.png)
1. Si no tiene un rol de IAM, elija **Crear nuevo rol**.
![\[Ubicación de Crear rol de IAM\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/10a-create-iam-role.png)
1. En la página **Crear un rol de IAM**, elija **Cualquier bucket de S3** y elija **Crear rol**.
![\[Página Crear rol de IAM\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/10-create-iam-role.png)
1.
------
#### [ Non PyTorch Frameworks ]
En la sección de **Configuración de entrada**, escriba la ruta del URI del bucket de Amazon S3 que contiene los artefactos del modelo en el campo **Ubicación de artefactos del modelo**. Los artefactos del modelo deben estar en un formato de archivo tar comprimido (`.tar.gz`).
En el campo de **Configuración de entrada de datos**, introduzca la cadena JSON que especifica la forma de los datos de entrada.
Para **Marco de machine learning**, elija el marco que prefiera.
![\[Página Configuración de entrada\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/neo-create-compilation-job-input-config.png)
Para ver ejemplos de cadenas JSON de datos de entrada que dependen de marcos, consulte [Qué formas de datos de entrada espera Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting.html#neo-troubleshooting-errors-preventing).
------
#### [ PyTorch Framework ]
Se aplican instrucciones similares a la compilación de PyTorch modelos. Sin embargo, si ha entrenado con el modelo PyTorch y está intentando compilarlo para `ml_*` (excepto`ml_inf`) el objetivo, puede especificar, si lo desea, la versión PyTorch que ha utilizado.
![\[Ejemplo de la sección Configuración de entrada que muestra dónde elegir la opción Versión del marco\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/compile_console_pytorch.png)
Para ver ejemplos de cadenas JSON de datos de entrada que dependen de marcos, consulte [Qué formas de datos de entrada espera Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting.html#neo-troubleshooting-errors-preventing).
**Notas**
Si guardó el modelo con la PyTorch versión 2.0 o posterior, el **campo de configuración de entrada de datos** es opcional. SageMaker Neo obtiene la configuración de entrada del archivo de definición del modelo con el que se crea PyTorch. Para obtener más información sobre cómo crear el archivo de definición, consulte la [PyTorch](neo-compilation-preparing-model.md#how-to-save-pytorch) sección sobre cómo *guardar modelos para SageMaker AI Neo*.
Al compilar `ml_*` instancias mediante un PyTorch framework, utilice el campo de **opciones del compilador** en la **configuración de salida** para proporcionar el tipo de datos correcto (`dtype`) de la entrada del modelo. El valor predeterminado se establece en `"float32"`.
![\[Ejemplo de la sección Configuración de salida\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/neo_compilation_console_pytorch_compiler_options.png)
**aviso**
Si especifica una ruta del URI del bucket de Amazon S3 que lleva al archivo `.pth`, aparecerá el siguiente error después de iniciar la compilación: `ClientError: InputConfiguration: Unable to untar input model.Please confirm the model is a tar.gz file`
------
1. Vaya a la sección de **Configuración de salida**. Elija dónde desea implementar su modelo. Puede implementar su modelo en un **Dispositivo de destino** o en una **Plataforma de destino**. Los dispositivos de destino incluyen dispositivos periféricos y en la nube. Las plataformas de destino hacen referencia a sistemas operativos, arquitectura y aceleradores específicos en los que desea que se ejecute su modelo.
En **Ubicación de salida de S3**, escriba la ruta o al bucket de S3 o donde desee almacenar el modelo. Si lo desea, puede añadir opciones del compilador en formato JSON en la sección **Opciones del compilador**.
![\[Página Configuración de salida\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/neo-console-output-config.png)
1. Compruebe el estado del trabajo de compilación cuando se inicie. Este estado del trabajo se encuentra en la parte superior de la página del **Trabajo de compilación**, como se muestra en la siguiente captura de pantalla. También puede comprobar su estado en la columna **Estado**.
![\[Estado del trabajo de compilación.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/12-run-model-compilation.png)
1. Compruebe el estado del trabajo de compilación cuando se haya completado. Puede comprobar el estado en la columna **Estado**, como se muestra en la siguiente captura de pantalla.
![\[Estado del trabajo de compilación.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/neo/12a-completed-model-compilation.png)
# Compilar un modelo (Amazon SageMaker AI SDK)
Puede usar la [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 del [SDK de Amazon SageMaker AI para Python](https://sagemaker.readthedocs.io/en/stable/) a fin de compilar un modelo entrenado y optimizarlo para un hardware de destino específico. La API debe invocarse en el objeto estimador utilizado durante el entrenamiento del modelo.
**nota**
Debe establecer la variable de `MMS_DEFAULT_RESPONSE_TIMEOUT` entorno en `500` al compilar el modelo con MXNet o PyTorch. La variable de entorno no es necesaria para TensorFlow.
El siguiente es un ejemplo de cómo se puede compilar un modelo con el objeto `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'})
```
El código compila el modelo, guarda el modelo optimizado y crea un modelo de SageMaker IA que se puede implementar en un punto final. `output_path`