Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Preparazione del modello per la compilazione
SageMaker Neo richiede modelli di apprendimento automatico per soddisfare forme di dati di input specifiche. La forma di input richiesta per la compilazione dipende dal framework di deep learning utilizzato. Una volta che la forma di input del modello è stata formattata correttamente, salva il modello in base ai requisiti seguenti. Una volta salvato il modello, comprimi gli artefatti del modello.
**Topics**
+ [Quali forme di dati di input si aspetta SageMaker Neo?](#neo-job-compilation-expected-inputs)
+ [Modelli di salvataggio per SageMaker Neo](#neo-job-compilation-how-to-save-model)
## Quali forme di dati di input si aspetta SageMaker Neo?
Prima di compilare il modello, assicurati che esso sia formattato correttamente. Neo si aspetta il nome e la forma degli input di dati previsti per il modello addestrato con il formato JSON o elenco. Gli input previsti sono specifici del framework.
Di seguito sono riportate le forme di input che SageMaker Neo si aspetta:
### Keras
Specifica il nome e la forma (formato NCHW) degli input di dati previsti utilizzando un formato dizionario per il modello addestrato. Nota che mentre gli artefatti del modello Keras devono essere caricati nel formato NHWC (channel-last), DataInputConfig devono essere specificati nel formato NCHW (channel-first). I formati di dizionario richiesti sono i seguenti:
+ Per un input: `{'input_1':[1,3,224,224]}`
+ Per due input: `{'input_1': [1,3,224,224], 'input_2':[1,3,224,224]}`
### MXNet/ONNX
Specifica il nome e la forma (formato NCHW) degli input di dati previsti utilizzando un formato dizionario per il modello addestrato. I formati di dizionario richiesti sono i seguenti:
+ Per un input: `{'data':[1,3,1024,1024]}`
+ Per due input: `{'var1': [1,1,28,28], 'var2':[1,1,28,28]}`
### PyTorch
Per un PyTorch modello, non è necessario fornire il nome e la forma degli input di dati previsti se si soddisfano entrambe le seguenti condizioni:
+ Avete creato il file di definizione del modello utilizzando la PyTorch versione 2.0 o una versione successiva. Per ulteriori informazioni su come creare il file di definizione, consulta la [PyTorch](#how-to-save-pytorch) sezione in *Salvare modelli per SageMaker Neo*.
+ Stai compilando il tuo modello per un'istanza cloud. Per ulteriori informazioni sui tipi di istanze supportati da SageMaker Neo, consulta[Tipi di istanze e framework supportati](neo-supported-cloud.md).
Se soddisfi queste condizioni, SageMaker Neo ottiene la configurazione di input dal file di definizione del modello (.pt o .pth) con cui crei. PyTorch
In caso contrario, devi completare le attività seguenti:
Specifica il nome e la forma (formato NCHW) degli input di dati previsti utilizzando un formato dizionario per il modello addestrato. In alternativa, puoi specificare la forma solo utilizzando un formato elenco. I formati di dizionario richiesti sono i seguenti:
+ Per un input in formato dizionario: `{'input0':[1,3,224,224]}`
+ Per un input in formato elenco: `[[1,3,224,224]]`
+ Per due input in formato dizionario: `{'input0':[1,3,224,224], 'input1':[1,3,224,224]}`
+ Per due input in formato elenco: `[[1,3,224,224], [1,3,224,224]]`
### TensorFlow
Specifica il nome e la forma (formato NHWC) dei dati di input previsti utilizzando un formato dizionario per il modello sottoposto ad addestramento. I formati di dizionario richiesti sono i seguenti:
+ Per un input: `{'input':[1,1024,1024,3]}`
+ Per due input: `{'data1': [1,28,28,1], 'data2':[1,28,28,1]}`
### TFLite
Specifica il nome e la forma (formato NHWC) dei dati di input previsti utilizzando un formato dizionario per il modello sottoposto ad addestramento. I formati di dizionario richiesti sono i seguenti:
+ Per un input: `{'input':[1,224,224,3]}`
**Nota**
SageMaker Neo supporta TensorFlow Lite solo per dispositivi edge. Per un elenco dei target dei dispositivi SageMaker Neo edge supportati, consulta la [dispositivi](neo-supported-devices-edge-devices.md#neo-supported-edge-devices) pagina SageMaker Neo. Per un elenco degli obiettivi delle istanze cloud SageMaker Neo supportati, consulta la [Tipi di istanze e framework supportati](neo-supported-cloud.md) pagina SageMaker Neo.
### XGBoost
Un nome e la forma dei dati di input non sono necessari.
## Modelli di salvataggio per SageMaker Neo
Gli esempi di codice seguenti mostrano come salvare il modello per renderlo compatibile con Neo. I modelli devono essere impacchettati come file tar compressi (`*.tar.gz`).
### Keras
I modelli Keras richiedono un file di definizione del modello (`.h5`).
Esistono due opzioni per salvare il modello Keras in modo da renderlo compatibile con SageMaker Neo:
1. Esportarlo in formato `.h5` con `model.save("", save_format="h5")`.
1. Bloccare il file `SavedModel` dopo l'esportazione.
Di seguito è riportato un esempio di come esportare un modello `tf.keras` come grafico congelato (opzione due):
```
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()
```
**avvertimento**
Non esportare il modello con la classe `SavedModel` utilizzando `model.save(, save_format='tf')`. Questo formato è adatto per l’addestramento, ma non per l'inferenza.
### MXNet
MXNet i modelli devono essere salvati come un singolo file di simboli `*-symbol.json` e un singolo parametro`*.params files`.
------
#### [ Gluon Models ]
Definisci la rete neurale utilizzando la classe `HybridSequential`. In tal modo, verrà eseguito il codice nello stile della programmazione simbolica (al contrario della programmazione 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()
```
Per ulteriori informazioni sull'ibridazione dei modelli, consultate la documentazione di [MXNet hybridize](https://mxnet.apache.org/versions/1.7.0/api/python/docs/tutorials/packages/gluon/blocks/hybridize.html).
------
#### [ Gluon Model Zoo (GluonCV) ]
I modelli zoo del modello GluonCV sono preibridati. Quindi, puoi semplicemente esportarli.
```
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 ]
Tutti i modelli non Gluon quando vengono salvati su disco utilizzano file `*-symbol` e `*.params`. Sono quindi già nel formato corretto per 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 i modelli devono essere salvati come file di definizione (`.pt`o`.pth`) con il tipo di dati di input di. `float32`
Per salvare il modello, utilizza il metodo `torch.jit.trace` seguito dal metodo `torch.save`. Questo processo salva un oggetto in un file su disco e, per impostazione predefinita, utilizza il modulo pickle Python (`pickle_module=pickle`) per salvare gli oggetti e alcuni metadati. Dopodiché, converti il modello salvato in un file tar compresso.
```
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()
```
Se si salva il modello con la PyTorch versione 2.0 o successiva, SageMaker Neo ricava la configurazione di input per il modello (il nome e la forma per l'input) dal file di definizione. In tal caso, non è necessario specificare la configurazione di immissione dei dati in SageMaker AI quando si compila il modello.
Se vuoi impedire a SageMaker Neo di derivare la configurazione di input, puoi impostare il `_store_inputs` parametro su to`torch.jit.trace`. `False` Se si esegue questa operazione, è necessario specificare la configurazione di immissione dei dati in SageMaker AI quando si compila il modello.
Per ulteriori informazioni sul `torch.jit.trace` metodo, consulta [TORCH.JIT.TRACE](https://pytorch.org/docs/stable/generated/torch.jit.trace.html#torch.jit.trace) nella documentazione. PyTorch
### TensorFlow
TensorFlow richiede uno `.pb` o un `.pbtxt` file e una directory di variabili che contenga variabili. Per i modelli bloccati, è richiesto solo un file `.pb` o `.pbtxt`.
Il codice di esempio seguente mostra come utilizzare il comando tar di Linux per comprimere il modello. Esegui quanto segue nel tuo terminale o in un notebook Jupyter (se usi un notebook Jupyter, inserisci il comando magico `!` all'inizio dell'istruzione):
```
# 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
```
I flag di comando utilizzati in questo esempio eseguono le seguenti operazioni:
+ `c`: creazione di un archivio
+ `z`: compressione dell'archivio con gzip
+ `v`: visualizzazione dello stato di avanzamento dell'archivio
+ `f`: specificazione del nome del file dell'archivio
### Strumenti di valutazione integrati
Gli strumenti di valutazione integrati sono realizzati mediante container specifici del framework o container specifici dell'algoritmo. Gli oggetti degli strumenti di valutazione sia per l'algoritmo integrato che per gli strumenti di valutazione specifici del framework salvano il modello nel formato corretto quando il modello viene addestrato utilizzando il metodo `.fit` integrato.
Ad esempio, puoi usare `sagemaker.TensorFlow` a per definire uno TensorFlow stimatore:
```
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')
```
Dopodiché, addestra il modello con il metodo integrato `.fit`:
```
estimator.fit(inputs)
```
Prima di compilare definitivamente il modello con il metodo `compile_model` integrato:
```
# 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')
```
Puoi anche usare la `sagemaker.estimator.Estimator` classe per inizializzare un oggetto estimatore per l'addestramento e la compilazione di un algoritmo integrato con il `compile_model` metodo dell'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')
```
Per ulteriori informazioni sulla compilazione di modelli con SageMaker Python SDK, consulta. [Compila un modello (Amazon SageMaker AI SDK)](neo-job-compilation-sagemaker-sdk.md)