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à. # Compilazione di modelli con Neo Questa sezione mostra come creare, descrivere, arrestare ed elencare lavori di compilazione. Le seguenti opzioni sono disponibili in Amazon SageMaker Neo per la gestione dei processi di compilazione per i modelli di apprendimento automatico: la AWS Command Line Interface console Amazon SageMaker AI o l'Amazon SageMaker SDK. **Topics** + [ # Preparazione del modello per la compilazione ](neo-compilation-preparing-model.md) + [ # Compilazione di un modello (AWS Command Line Interface) ](neo-job-compilation-cli.md) + [ # Compila un modello (Amazon SageMaker AI Console) ](neo-job-compilation-console.md) + [ # Compila un modello (Amazon SageMaker AI SDK) ](neo-job-compilation-sagemaker-sdk.md) # 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) # Compilazione di un modello (AWS Command Line Interface) Questa sezione mostra come gestire i processi di compilazione di Amazon SageMaker Neo per modelli di machine learning utilizzando AWS Command Line Interface (CLI). Puoi creare, descrivere, arrestare ed elencare i processi di compilazione. 1. Creazione di un processo di compilazione. Con il funzionamento dell'[CreateCompilationJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateCompilationJob.html)API, puoi specificare il formato di input dei dati, il bucket S3 in cui archiviare il modello, il bucket S3 in cui scrivere il modello compilato e il dispositivo o la piattaforma hardware di destinazione. La tabella seguente mostra come configurare l'API `CreateCompilationJob` in base al fatto che la destinazione sia un dispositivo o una piattaforma. ------ #### [ 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 } } ``` Facoltativamente, puoi specificare la versione del framework che hai usato con il [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 se hai usato il PyTorch framework per addestrare il tuo modello e il tuo dispositivo di destinazione è un bersaglio. `ml_* ` ``` { "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 } } ``` **Note:** Se hai salvato il modello utilizzando la PyTorch versione 2.0 o successiva, il `DataInputConfig` campo è facoltativo. SageMaker AI Neo ottiene la configurazione di input dal file di definizione del modello con cui crei PyTorch. Per ulteriori informazioni su come creare il file di definizione, consulta la [PyTorch](neo-compilation-preparing-model.md#how-to-save-pytorch) sezione sotto *Salvare modelli per SageMaker AI Neo*. Questo campo API è supportato solo per 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** Per il funzionamento dell'API `OutputConfig`, le operazioni `TargetDevice` e `TargetPlatform` si escludono a vicenda. Devi scegliere una delle due opzioni. Per trovare esempi di stringhe JSON di `DataInputConfig` a seconda dei framework, vedi [Quali forme di dati di input si aspetta Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting-compilation.html#neo-troubleshooting-errors-preventing). Per ulteriori informazioni sull'impostazione delle configurazioni, consulta la sezione [InputConfig[OutputConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputConfig.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InputConfig.html), e le operazioni [TargetPlatform](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TargetPlatform.html)API nel riferimento all' SageMaker API. 1. Dopo aver configurato il file JSON, esegui il comando seguente per creare il processo di compilazione: ``` aws sagemaker create-compilation-job \ --cli-input-json file://job.json \ --region us-west-2 # You should get CompilationJobArn ``` 1. Descrivi il processo di compilazione eseguendo il comando seguente: ``` aws sagemaker describe-compilation-job \ --compilation-job-name $JOB_NM \ --region us-west-2 ``` 1. Interrompi il processo di compilazione eseguendo il comando seguente: ``` aws sagemaker stop-compilation-job \ --compilation-job-name $JOB_NM \ --region us-west-2 # There is no output for compilation-job operation ``` 1. Elenca il processo di compilazione eseguendo il comando seguente: ``` aws sagemaker list-compilation-jobs \ --region us-west-2 ``` # Compila un modello (Amazon SageMaker AI Console) Puoi creare un processo di compilazione Amazon SageMaker Neo nella console Amazon SageMaker AI. 1. Nella console **Amazon SageMaker AI**, scegli **Lavori di compilazione**, quindi scegli **Crea processo di compilazione.** ![\[Crei un processo di compilazione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/8-create-compilation-job.png) 1. Nella pagina **Crea un processo di compilazione**, per **Nome del processo**, immetti un nome. Quindi seleziona un **ruolo IAM**. ![\[Pagina Crea un processo di compilazione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/9-create-compilation-job-config.png) 1. Se non disponi di un ruolo IAM, scegli **Create a new role (Crea un nuovo ruolo)**. ![\[Crea una posizione per il ruolo IAM.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/10a-create-iam-role.png) 1. Nella pagina **Create an IAM role (Crea un ruolo IAM)**, scegli **Any S3 bucket (Qualsiasi bucket S3)** e seleziona **Create role (Crea ruolo)**. ![\[Pagina Crea un ruolo IAM.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/10-create-iam-role.png) 1. ------ #### [ Non PyTorch Frameworks ] Nella sezione **Configurazione di input**, immetti il percorso completo dell’URI del bucket Amazon S3 che contiene gli artefatti del modello nel campo di input **Posizione degli artefatti dei modelli**. Gli artefatti del modello devono essere in un formato di file tarball compresso (`.tar.gz`). Per il campo **Configurazione di input dei dati**, immetti la stringa JSON che specifica la forma dei dati di input. Per **Framework di machine learning**, scegli il framework a tua scelta. ![\[Pagina Configurazione di input.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/neo-create-compilation-job-input-config.png) Per trovare esempi di stringhe JSON di forme di dati di input che dipendono dai framework, vedi [Quali forme di dati di input si aspetta Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting.html#neo-troubleshooting-errors-preventing). ------ #### [ PyTorch Framework ] Istruzioni simili si applicano alla compilazione PyTorch dei modelli. Tuttavia, se ti sei allenato con PyTorch e stai cercando di compilare il modello per `ml_*` (eccetto`ml_inf`) target, puoi facoltativamente specificare la versione che hai usato. PyTorch ![\[Sezione Configurazione di input di esempio che mostra dove scegliere la Versione del framework.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/compile_console_pytorch.png) Per trovare esempi di stringhe JSON di forme di dati di input che dipendono dai framework, vedi [Quali forme di dati di input si aspetta Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting.html#neo-troubleshooting-errors-preventing). **Note** Se hai salvato il modello utilizzando la PyTorch versione 2.0 o successiva, il **campo di configurazione dell'immissione dei dati è facoltativo**. SageMaker Neo ottiene la configurazione di input dal file di definizione del modello con cui crei PyTorch. Per ulteriori informazioni su come creare il file di definizione, consulta la [PyTorch](neo-compilation-preparing-model.md#how-to-save-pytorch) sezione sotto *Salvare modelli per SageMaker AI Neo*. Durante la compilazione di `ml_*` istanze utilizzando il PyTorch framework, utilizzate il campo **delle opzioni del compilatore** in **Output Configuration** per fornire il tipo di dati corretto (`dtype`) dell'input del modello. Il valore predefinito è impostato su `"float32"`. ![\[Sezione Configurazione di output di esempio.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/neo_compilation_console_pytorch_compiler_options.png) **avvertimento** Se specifichi un percorso URI del bucket Amazon S3 che conduce al file `.pth`, riceverai il seguente errore dopo l'avvio della compilazione: `ClientError: InputConfiguration: Unable to untar input model.Please confirm the model is a tar.gz file` ------ 1. Vai alla sezione **Configurazione di output**. Scegli dove vuoi distribuire il modello. Puoi distribuire il tuo modello su un **dispositivo di destinazione** o su una **piattaforma di destinazione**. I dispositivi di destinazione includono dispositivi cloud ed edge. Le piattaforme di destinazione si riferiscono a sistemi operativi, architetture e acceleratori specifici su cui si desidera che il modello venga eseguito. Per **Posizione di output S3**, immetti il percorso verso il bucket S3 in cui desideri memorizzare il modello. Facoltativamente, puoi aggiungere opzioni del compilatore in formato JSON nella sezione **Opzioni del compilatore.** ![\[Pagina Configurazione di output.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/neo-console-output-config.png) 1. Verifica lo stato del processo di compilazione quando viene avviato. Questo stato del processo è disponibile nella parte superiore della pagina **Processi di compilazione**, come mostrato nello screenshot seguente. Puoi anche controllarne lo stato nella colonna **Stato**. ![\[Stato del processo di compilazione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/12-run-model-compilation.png) 1. Verifica lo stato del processo di compilazione quando è completato. Puoi controllare lo stato nella colonna **Stato**, come mostrato nello screenshot seguente. ![\[Stato del processo di compilazione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/neo/12a-completed-model-compilation.png) # Compila un modello (Amazon SageMaker AI SDK) Puoi utilizzare 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 nell'[SDK Amazon SageMaker AI per Python per](https://sagemaker.readthedocs.io/en/stable/) compilare un modello addestrato e ottimizzarlo per hardware di destinazione specifico. L'API deve essere richiamata sull'oggetto dello strumento di valutazione utilizzato durante l'addestramento del modello. **Nota** È necessario impostare la variabile di `MMS_DEFAULT_RESPONSE_TIMEOUT` ambiente su `500` quando si compila il modello con o. MXNet PyTorch La variabile di ambiente non è necessaria per TensorFlow. Di seguito è riportato un esempio di come è possibile compilare un modello utilizzando l'oggetto `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'}) ``` Il codice compila il modello, salva il modello ottimizzato in `output_path` e crea un modello di SageMaker intelligenza artificiale che può essere distribuito su un endpoint.