Preparazione del modello per la compilazione - Amazon SageMaker
Quali forme di dati di input si aspetta SageMaker Neo?Modelli di salvataggio per SageMaker Neo

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.

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 JSON formato o formato elenco. Gli input previsti sono specifici del framework.

Di seguito sono riportate le forme di input che SageMaker Neo si aspetta:

Specificate il nome e la forma (NCHWformato) degli input di dati previsti utilizzando un formato di 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 (channel-first). NCHW 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]}

Specificate il nome e la forma (NCHWformato) degli input di dati previsti utilizzando un formato di 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]}

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 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, consultaTipi di istanze e framework supportati.

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:

Specificate il nome e la forma (NCHWformato) degli input di dati previsti utilizzando un formato di 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]]

Specificate il nome e la forma (NHWCformato) degli input di dati previsti utilizzando un formato di dizionario per il modello addestrato. 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]}

Specificate il nome e la forma (NHWCformato) degli input di dati previsti utilizzando un formato di dizionario per il modello addestrato. I formati di dizionario richiesti sono i seguenti:

  • Per un input: {'input':[1,224,224,3]}

Nota

SageMaker Neo supporta solo TensorFlow Lite per dispositivi edge. Per un elenco dei target dei dispositivi SageMaker Neo edge supportati, consulta la Dispositivi pagina SageMaker Neo. Per un elenco degli obiettivi delle istanze cloud SageMaker Neo supportati, consulta la Tipi di istanze e framework supportati pagina SageMaker Neo.

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).

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("<model-name>", save_format="h5").

  2. 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(<path>, save_format='tf'). Questo formato è adatto per l’addestramento, ma non per l'inferenza.

MXNeti 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('<model_name>') # this will create model-symbol.json and model-0000.params files

import tarfile
tar = tarfile.open("<model_name>.tar.gz", "w:gz")
for name in ["<model_name>-0000.params", "<model_name>-symbol.json"]:
    tar.add(name)
tar.close()

Per ulteriori informazioni sull'ibridazione dei modelli, consultate la documentazione di MXNethybridize.

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('<model_name>', pretrained=True) # For example, choose <model_name> as resnet18_v1
export_block('<model_name>', net, preprocess=True, layout='HWC')

tar = tarfile.open("<model_name>.tar.gz", "w:gz")

for name in ["<model_name>-0000.params", "<model_name>-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('<model_name>',0,sym,args,aux) # this will create <model_name>-symbol.json and <model_name>-0000.params files

import tarfile
tar = tarfile.open("<model_name>.tar.gz", "w:gz")

for name in ["<model_name>-0000.params", "<model_name>-symbol.json"]:
    tar.add(name)
tar.close()

PyTorch i modelli devono essere salvati come file di definizione (.pto.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 al SageMaker momento della compilazione del modello.

Se vuoi impedire a SageMaker Neo di derivare la configurazione di input, puoi impostare il _store_inputs parametro su. torch.jit.trace False Se si esegue questa operazione, è necessario specificare la configurazione di immissione dei dati al SageMaker momento della compilazione del modello.

Per ulteriori informazioni sul torch.jit.trace metodo, vedereTORCH. JIT. TRACEnella PyTorch documentazione.

TensorFlow richiede uno .pb o un .pbtxt file e una directory di variabili che contenga le 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

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 di Python: SageMaker SDK

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 SDK Python, vedere. Compila un modello (Amazon SageMakerSDK)