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à. # Carichi di lavoro di trasformazione dei dati con Processing SageMaker SageMaker L'elaborazione si riferisce alle capacità dell' SageMaker IA di eseguire attività di pre e post elaborazione dei dati, ingegneria delle funzionalità e valutazione dei modelli sull'infrastruttura completamente gestita dell' SageMaker IA. Queste attività vengono eseguite come [processi di elaborazione](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingJob.html). Di seguito vengono fornite informazioni e risorse per conoscere SageMaker l'elaborazione. Utilizzando l'API SageMaker Processing, i data scientist possono eseguire script e notebook per elaborare, trasformare e analizzare i set di dati per prepararli all'apprendimento automatico. Se combinato con le altre attività critiche di apprendimento automatico fornite dall' SageMaker IA, come la formazione e l'hosting, Processing offre i vantaggi di un ambiente di apprendimento automatico completamente gestito, incluso tutto il supporto per la sicurezza e la conformità integrato nell'intelligenza artificiale. SageMaker Hai la flessibilità di utilizzare i contenitori di elaborazione dati integrati o di utilizzare contenitori personalizzati per logiche di elaborazione personalizzate e quindi inviare lavori da eseguire su un'infrastruttura gestita dall' SageMaker intelligenza artificiale. **Nota** Puoi creare un processo di elaborazione a livello di codice richiamando l'azione dell'[CreateProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html)API in qualsiasi linguaggio supportato dall' SageMaker intelligenza artificiale o utilizzando il. AWS CLI Per informazioni su come questa azione dell'API si traduce in una funzione nella lingua di tua scelta, consulta la sezione [Vedere anche](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html#API_CreateProcessingJob_SeeAlso) di CreateProcessingJob e scegli un SDK. Ad esempio, per gli utenti Python, consulta la sezione [Amazon SageMaker Processing](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_processing.html) di Python SageMaker SDK. In alternativa, consulta la sintassi di richiesta completa di [create\$1processing\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_processing_job.html) in AWS SDK per Python (Boto3). Il diagramma seguente mostra come Amazon SageMaker AI esegue un processo di elaborazione. Amazon SageMaker AI prende lo script, copia i dati da Amazon Simple Storage Service (Amazon S3) e quindi crea un contenitore di elaborazione. L'infrastruttura sottostante per un processo di elaborazione è completamente gestita da Amazon SageMaker AI. Dopo aver inviato un processo di elaborazione, l' SageMaker intelligenza artificiale avvia le istanze di calcolo, elabora e analizza i dati di input e rilascia le risorse una volta completato. L'output del processo di elaborazione viene archiviato nel bucket Amazon S3 che hai specificato. **Nota** I dati di input devono essere archiviati in un bucket S3 Amazon. In alternativa, puoi utilizzare Amazon Athena o Amazon Redshift come origini input. ![\[Esecuzione di un processo di elaborazione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/Processing-1.png) **Suggerimento** Per conoscere le migliori pratiche per il calcolo dei processi di addestramento distribuito ed elaborazione del machine learning (ML) in generale, consulta [Elaborazione distribuita con best practice di SageMaker intelligenza artificiale](distributed-training-options.md). ## Usa Amazon SageMaker Processing Sample Notebook Sono disponibili due notebook Jupyter di esempio che mostrano come eseguire la preelaborazione dei dati, la valutazione del modello o entrambe le attività. [Per un taccuino di esempio che mostra come eseguire script scikit-learn per eseguire la preelaborazione dei dati e l'addestramento e la valutazione dei modelli con SageMaker Python SDK for Processing, vedi scikit-learn Processing.](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation) Questo notebook mostra anche come utilizzare il container personalizzato per eseguire carichi di lavoro di elaborazione con le librerie Python e altre dipendenze specifiche. Per un notebook di esempio che mostra come utilizzare Amazon SageMaker Processing per eseguire la preelaborazione distribuita dei dati con Spark, consulta [Distributed Processing (Spark](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_processing/spark_distributed_data_processing/sagemaker-spark-processing.ipynb)). Questo taccuino mostra anche come addestrare un modello di regressione utilizzando XGBoost un set di dati preelaborato. Per istruzioni su come creare e accedere alle istanze di notebook Jupyter da utilizzare per eseguire questi esempi in AI, consulta. SageMaker [Istanze SageMaker per notebook Amazon](nbi.md) Dopo aver creato un'istanza di notebook e averla aperta, scegli la scheda **Esempi SageMaker AI** per visualizzare un elenco di tutti gli esempi di IA. SageMaker Per aprire un notebook, seleziona la relativa scheda **Utilizza** e scegli **Crea copia**. ## Monitora i SageMaker processi di elaborazione di Amazon con CloudWatch log e metriche Amazon SageMaker Processing fornisce CloudWatch log e parametri Amazon per monitorare i processi di elaborazione. CloudWatch fornisce CPU, GPU, memoria, memoria GPU e parametri del disco e registrazione degli eventi. Per ulteriori informazioni, consultare [Metriche di Amazon SageMaker AI in Amazon CloudWatch](monitoring-cloudwatch.md) e [CloudWatch Registri per Amazon SageMaker AI](logging-cloudwatch.md). # Eseguire un processo Processing con Apache Spark Apache Spark è un motore di analisi unificato per l'elaborazione di dati su larga scala. Amazon SageMaker AI fornisce immagini Docker predefinite che includono Apache Spark e altre dipendenze necessarie per eseguire processi di elaborazione dati distribuiti. Di seguito viene fornito un esempio su come eseguire un processo Amazon SageMaker Processing utilizzando Apache Spark. Con [Amazon SageMaker Python](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk) SDK, puoi applicare facilmente trasformazioni di dati ed estrarre funzionalità (ingegneria delle funzionalità) utilizzando il framework Spark. Per informazioni sull'utilizzo dell'SDK Python SageMaker per eseguire i processi di elaborazione Spark, consulta [Elaborazione di dati con Spark](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_processing.html#data-processing-with-spark) in [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/). Un repository di codice che contiene il codice sorgente e i Dockerfile per le immagini Spark è disponibile su [GitHub](https://github.com/aws/sagemaker-spark-container). Puoi usare la classe [https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.spark.processing.PySparkProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.spark.processing.PySparkProcessor) o [https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.spark.processing.SparkJarProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.spark.processing.SparkJarProcessor) per eseguire l'applicazione Spark all'interno di un processo di elaborazione. Tieni presente che puoi impostare maxRuntimeInSeconds su un limite di runtime massimo di 5 giorni. Per quanto riguarda il tempo di esecuzione e il numero di istanze utilizzate, i carichi di lavoro Simple Spark vedono una relazione quasi lineare tra il numero di istanze e il tempo di completamento. L'esempio di codice seguente mostra come eseguire un processo di elaborazione che invocano lo script PySpark `preprocess.py`. ``` from sagemaker.spark.processing import PySparkProcessor spark_processor = PySparkProcessor( base_job_name="spark-preprocessor", framework_version="2.4", role=role, instance_count=2, instance_type="ml.m5.xlarge", max_runtime_in_seconds=1200, ) spark_processor.run( submit_app="preprocess.py", arguments=['s3_input_bucket', bucket, 's3_input_key_prefix', input_prefix, 's3_output_bucket', bucket, 's3_output_key_prefix', output_prefix] ) ``` Per un'analisi approfondita, consulta il [notebook di esempio](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_processing/spark_distributed_data_processing/sagemaker-spark-processing.html) di elaborazione dei dati distribuita con Apache Spark ed Elaborazione SageMaker. Se non utilizzi [Amazon SageMaker AI Python SDK](https://sagemaker.readthedocs.io/) e una delle sue classi Processor per recuperare le immagini predefinite, puoi recuperarle manualmente. Le immagini Docker predefinite di SageMaker sono memorizzate in Amazon Elastic Container Registry (Amazon ECR). Per un elenco completo delle immagini Docker predefinite disponibili, consulta il documento delle [immagini disponibili](https://github.com/aws/sagemaker-spark-container/blob/master/available_images.md). Per ulteriori informazioni sull’utilizzo di SageMaker Python SDK con container Processing, consulta [Amazon SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/). # Eseguire un processo Processing con scikit-learn È possibile utilizzare Amazon SageMaker Processing per elaborare i dati e valutare i modelli con script scikit-learn in un’immagine Docker fornita da Amazon SageMaker AI. Di seguito viene fornito un esempio su come eseguire un processo Amazon SageMaker Processing utilizzando scikit-learn. Per un notebook di esempio che mostra come eseguire gli script scikit-learn utilizzando un’immagine Docker fornita e gestita da SageMaker AI per pre-elaborare i dati e valutare i modelli, consulta [scikit-learn Processing](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation). Per utilizzare questo notebook, è necessario installare SageMaker AI Python SDK per Processing. Questo notebook esegue un processo di elaborazione utilizzando la classe `SKLearnProcessor` dall'SDK Python SageMaker per eseguire uno script scikit-learn fornito. Lo script preelabora i dati, addestra un modello utilizzando un processo di addestramento SageMaker e quindi esegue un processo di elaborazione per valutare il modello addestrato. Il processo di elaborazione stima il modo in cui il modello dovrebbe funzionare in produzione. Per ulteriori informazioni sull'utilizzo dell'SDK Python SageMaker con container di elaborazione, consulta [Python SDK SageMaker](https://sagemaker.readthedocs.io/en/stable/). Per un elenco completo delle immagini Docker predefinite disponibili per i processi di elaborazione, consulta [Percorsi di registro Docker e codice di esempio](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths). L’esempio di codice seguente mostra come il notebook utilizza `SKLearnProcessor` per eseguire lo script scikit-learn utilizzando un’immagine Docker fornita e gestita da SageMaker AI, anziché la tua immagine Docker. ``` from sagemaker.sklearn.processing import SKLearnProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput sklearn_processor = SKLearnProcessor(framework_version='0.20.0', role=role, instance_type='ml.m5.xlarge', instance_count=1) sklearn_processor.run(code='preprocessing.py', inputs=[ProcessingInput( source='s3://path/to/my/input-data.csv', destination='/opt/ml/processing/input')], outputs=[ProcessingOutput(source='/opt/ml/processing/output/train'), ProcessingOutput(source='/opt/ml/processing/output/validation'), ProcessingOutput(source='/opt/ml/processing/output/test')] ) ``` Per elaborare i dati in parallelo utilizzando Scikit-Learn su Elaborazione Amazon SageMaker è possibile eseguire una partizione degli oggetti di input con il tasto S3 impostando `s3_data_distribution_type='ShardedByS3Key'` all'interno di `ProcessingInput` in modo che ogni istanza riceva circa lo stesso numero di oggetti di input. # Elaborazione di dati con processori Framework A `FrameworkProcessor` può eseguire processi di elaborazione con un framework di machine learning specifico, fornendoti un contenitore SageMaker gestito da Amazon AI per qualsiasi framework di apprendimento automatico tu scelga. `FrameworkProcessor`fornisce contenitori predefiniti per i seguenti framework di apprendimento automatico: Hugging Face,,, e. MXNet PyTorch TensorFlow XGBoost La classe `FrameworkProcessor` fornisce anche la personalizzazione della configurazione del container. La classe `FrameworkProcessor` supporta la specificazione di una directory di origine `source_dir` per gli script di elaborazione e le dipendenze. Con questa funzionalità, è possibile concedere al processore l'accesso a più script in una directory invece di specificare un solo script. `FrameworkProcessor` supporta anche l'inclusione di un file `requirements.txt` nella `source_dir` per personalizzare le librerie Python da installare nel container. Per ulteriori informazioni sulla `FrameworkProcessor` classe e sui relativi metodi e parametri, consulta [FrameworkProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.processing.FrameworkProcessor)l'SDK *Amazon SageMaker AI Python*. Per vedere esempi di utilizzo di un `FrameworkProcessor` per ciascuno dei framework di machine learning supportati, consulta i seguenti argomenti. **Topics** + [Esempio di codice utilizzato HuggingFaceProcessor nell'SDK Amazon SageMaker Python](processing-job-frameworks-hugging-face.md) + [MXNet Processore Framework](processing-job-frameworks-mxnet.md) + [PyTorch Processore Framework](processing-job-frameworks-pytorch.md) + [TensorFlow Processore Framework](processing-job-frameworks-tensorflow.md) + [XGBoost Processore Framework](processing-job-frameworks-xgboost.md) # Esempio di codice utilizzato HuggingFaceProcessor nell'SDK Amazon SageMaker Python Hugging Face è un fornitore open source di modelli di elaborazione del linguaggio naturale (NLP). L'`HuggingFaceProcessor`SDK di Amazon SageMaker Python ti offre la possibilità di eseguire processi di elaborazione con gli script Hugging Face. Quando utilizzi `HuggingFaceProcessor`, puoi sfruttare un container Docker creato da Amazon con un ambiente Hugging Face gestito in modo da non dover portare il tuo container. Il seguente esempio di codice mostra come utilizzare il `HuggingFaceProcessor` per eseguire il processo di elaborazione utilizzando un'immagine Docker fornita e gestita da AI. SageMaker Nota che quando esegui il job, puoi specificare una directory contenente gli script e le dipendenze nell'`source_dir`argomento e puoi avere un `requirements.txt` file all'interno della tua `source_dir` directory che specifica le dipendenze per i tuoi script di elaborazione. SageMaker L'elaborazione installa automaticamente le dipendenze presenti nel `requirements.txt` contenitore. ``` from sagemaker.huggingface import HuggingFaceProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the HuggingFaceProcessor hfp = HuggingFaceProcessor( role=get_execution_role(), instance_count=1, instance_type='ml.g4dn.xlarge', transformers_version='4.4.2', pytorch_version='1.6.0', base_job_name='frameworkprocessor-hf' ) #Run the processing job hfp.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input/data/' ) ], outputs=[ ProcessingOutput(output_name='train', source='/opt/ml/processing/output/train/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='test', source='/opt/ml/processing/output/test/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='val', source='/opt/ml/processing/output/val/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}') ] ) ``` Se hai un file `requirements.txt`, dovrebbe essere un elenco di librerie che desideri installare nel container. Il percorso per `source_dir` può essere un percorso URI relativo, assoluto o Amazon S3. Tuttavia, se utilizzi un URI Amazon S3, deve puntare a un file tar.gz. Puoi avere più script nella directory specificata per `source_dir`. Per ulteriori informazioni sulla `HuggingFaceProcessor` classe, consulta [Hugging Face Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html) nell'SDK *Amazon SageMaker * AI Python. # MXNet Processore Framework Apache MXNet è un framework di deep learning open source comunemente usato per l'addestramento e la distribuzione di reti neurali. L'`MXNetProcessor`SDK Amazon SageMaker Python ti offre la possibilità di eseguire processi di elaborazione con script. MXNet Quando usi il`MXNetProcessor`, puoi sfruttare un contenitore Docker creato da Amazon con un MXNet ambiente gestito in modo da non dover portare il tuo contenitore. Il seguente esempio di codice mostra come utilizzare il `MXNetProcessor` per eseguire il processo di elaborazione utilizzando un'immagine Docker fornita e gestita da AI. SageMaker Nota che quando esegui il job, puoi specificare una directory contenente gli script e le dipendenze nell'`source_dir`argomento e puoi avere un `requirements.txt` file all'interno della tua `source_dir` directory che specifica le dipendenze per i tuoi script di elaborazione. SageMaker L'elaborazione installa automaticamente le dipendenze presenti nel `requirements.txt` contenitore. ``` from sagemaker.mxnet import MXNetProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the MXNetProcessor mxp = MXNetProcessor( framework_version='1.8.0', py_version='py37', role=get_execution_role(), instance_count=1, instance_type='ml.c5.xlarge', base_job_name='frameworkprocessor-mxnet' ) #Run the processing job mxp.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input/data/' ) ], outputs=[ ProcessingOutput( output_name='processed_data', source='/opt/ml/processing/output/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}' ) ] ) ``` Se hai un file `requirements.txt`, dovrebbe essere un elenco di librerie che desideri installare nel container. Il percorso per `source_dir` può essere un percorso URI relativo, assoluto o Amazon S3. Tuttavia, se utilizzi un URI Amazon S3, deve puntare a un file tar.gz. Puoi avere più script nella directory specificata per `source_dir`. Per ulteriori informazioni sulla `MXNetProcessor` classe, consulta [MXNet Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html#mxnet-estimator) nell'SDK *Amazon SageMaker Python*. # PyTorch Processore Framework PyTorch è un framework di machine learning open source. L'`PyTorchProcessor`SDK Amazon SageMaker Python ti offre la possibilità di eseguire processi di elaborazione con script. PyTorch Quando usi il`PyTorchProcessor`, puoi sfruttare un contenitore Docker creato da Amazon con un PyTorch ambiente gestito in modo da non dover portare il tuo contenitore. Il seguente esempio di codice mostra come utilizzare il `PyTorchProcessor` per eseguire il processo di elaborazione utilizzando un'immagine Docker fornita e gestita da AI. SageMaker Nota che quando esegui il job, puoi specificare una directory contenente gli script e le dipendenze nell'`source_dir`argomento e puoi avere un `requirements.txt` file all'interno della tua `source_dir` directory che specifica le dipendenze per i tuoi script di elaborazione. SageMaker L'elaborazione installa automaticamente le dipendenze presenti nel `requirements.txt` contenitore. Per le PyTorch versioni supportate dall' SageMaker intelligenza artificiale, guarda le immagini disponibili del [Deep Learning Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). ``` from sagemaker.pytorch.processing import PyTorchProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the PyTorchProcessor pytorch_processor = PyTorchProcessor( framework_version='1.8', role=get_execution_role(), instance_type='ml.m5.xlarge', instance_count=1, base_job_name='frameworkprocessor-PT' ) #Run the processing job pytorch_processor.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input' ) ], outputs=[ ProcessingOutput(output_name='data_structured', source='/opt/ml/processing/tmp/data_structured', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='train', source='/opt/ml/processing/output/train', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='validation', source='/opt/ml/processing/output/val', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='test', source='/opt/ml/processing/output/test', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}'), ProcessingOutput(output_name='logs', source='/opt/ml/processing/logs', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}') ] ) ``` Se hai un file `requirements.txt`, dovrebbe essere un elenco di librerie che desideri installare nel container. Il percorso per `source_dir` può essere un percorso URI relativo, assoluto o Amazon S3. Tuttavia, se utilizzi un URI Amazon S3, deve puntare a un file tar.gz. Puoi avere più script nella directory specificata per `source_dir`. Per ulteriori informazioni sulla `PyTorchProcessor` classe, consulta [PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html) nell'SDK *Amazon SageMaker Python*. # TensorFlow Processore Framework TensorFlow è una libreria open source per l'apprendimento automatico e l'intelligenza artificiale. L'`TensorFlowProcessor`SDK Amazon SageMaker Python ti offre la possibilità di eseguire processi di elaborazione con script. TensorFlow Quando usi il`TensorFlowProcessor`, puoi sfruttare un contenitore Docker creato da Amazon con un TensorFlow ambiente gestito in modo da non dover portare il tuo contenitore. Il seguente esempio di codice mostra come utilizzare il `TensorFlowProcessor` per eseguire il processo di elaborazione utilizzando un'immagine Docker fornita e gestita da AI. SageMaker Nota che quando esegui il job, puoi specificare una directory contenente gli script e le dipendenze nell'`source_dir`argomento e puoi avere un `requirements.txt` file all'interno della tua `source_dir` directory che specifica le dipendenze per i tuoi script di elaborazione. SageMaker L'elaborazione installa automaticamente le dipendenze presenti nel `requirements.txt` contenitore. ``` from sagemaker.tensorflow import TensorFlowProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the TensorFlowProcessor tp = TensorFlowProcessor( framework_version='2.3', role=get_execution_role(), instance_type='ml.m5.xlarge', instance_count=1, base_job_name='frameworkprocessor-TF', py_version='py37' ) #Run the processing job tp.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input/data' ), ProcessingInput( input_name='model', source=f's3://{BUCKET}/{S3_PATH_TO_MODEL}', destination='/opt/ml/processing/input/model' ) ], outputs=[ ProcessingOutput( output_name='predictions', source='/opt/ml/processing/output', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}' ) ] ) ``` Se hai un file `requirements.txt`, dovrebbe essere un elenco di librerie che desideri installare nel container. Il percorso per `source_dir` può essere un percorso URI relativo, assoluto o Amazon S3. Tuttavia, se utilizzi un URI Amazon S3, deve puntare a un file tar.gz. Puoi avere più script nella directory specificata per `source_dir`. Per ulteriori informazioni sulla `TensorFlowProcessor` classe, consulta [TensorFlow Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) nell'SDK *Amazon SageMaker Python*. # XGBoost Processore Framework XGBoost è un framework di machine learning open source. L'`XGBoostProcessor`SDK Amazon SageMaker Python ti offre la possibilità di eseguire processi di elaborazione con script. XGBoost Quando utilizzi il XGBoost Processore, puoi sfruttare un contenitore Docker creato da Amazon con un XGBoost ambiente gestito in modo da non dover portare il tuo contenitore. Il seguente esempio di codice mostra come utilizzare il `XGBoostProcessor` per eseguire il processo di elaborazione utilizzando un'immagine Docker fornita e gestita da AI. SageMaker Nota che quando esegui il job, puoi specificare una directory contenente gli script e le dipendenze nell'`source_dir`argomento e puoi avere un `requirements.txt` file all'interno della tua `source_dir` directory che specifica le dipendenze per i tuoi script di elaborazione. SageMaker L'elaborazione installa automaticamente le dipendenze presenti nel `requirements.txt` contenitore. ``` from sagemaker.xgboost import XGBoostProcessor from sagemaker.processing import ProcessingInput, ProcessingOutput from sagemaker import get_execution_role #Initialize the XGBoostProcessor xgb = XGBoostProcessor( framework_version='1.2-2', role=get_execution_role(), instance_type='ml.m5.xlarge', instance_count=1, base_job_name='frameworkprocessor-XGB', ) #Run the processing job xgb.run( code='processing-script.py', source_dir='scripts', inputs=[ ProcessingInput( input_name='data', source=f's3://{BUCKET}/{S3_INPUT_PATH}', destination='/opt/ml/processing/input/data' ) ], outputs=[ ProcessingOutput( output_name='processed_data', source='/opt/ml/processing/output/', destination=f's3://{BUCKET}/{S3_OUTPUT_PATH}' ) ] ) ``` Se hai un file `requirements.txt`, dovrebbe essere un elenco di librerie che desideri installare nel container. Il percorso per `source_dir` può essere un percorso URI relativo, assoluto o Amazon S3. Tuttavia, se utilizzi un URI Amazon S3, deve puntare a un file tar.gz. Puoi avere più script nella directory specificata per `source_dir`. Per ulteriori informazioni sulla `XGBoostProcessor` classe, consulta [XGBoost Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/xgboost/xgboost.html) nell'SDK *Amazon SageMaker Python*. # Utilizzare il proprio codice di elaborazione Puoi installare librerie per eseguire gli script nel tuo contenitore di elaborazione o, in uno scenario più avanzato, puoi creare un contenitore di elaborazione personalizzato che soddisfi il contratto per l'esecuzione in Amazon AI. SageMaker Per ulteriori informazioni sui contenitori nell' SageMaker intelligenza artificiale, consulta. [Container Docker per l’addestramento e l’implementazione di modelli](docker-containers.md) Per una specifica formale che definisce il contratto per un container Amazon SageMaker Processing, consulta[Come creare un container di elaborazione personalizzato (scenario avanzato)](build-your-own-processing-container.md). **Topics** + [Eseguire script con il proprio container di elaborazione](processing-container-run-scripts.md) + [Come creare un container di elaborazione personalizzato (scenario avanzato)](build-your-own-processing-container.md) # Eseguire script con il proprio container di elaborazione Puoi utilizzare gli script scikit-learn per preelaborare i dati e valutare i modelli. Per vedere come eseguire gli script scikit-learn per eseguire queste attività, consulta il notebook di esempio [Elaborazione con scikit-learn](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation). Questo notebook utilizza la `ScriptProcessor` classe di Amazon SageMaker Python SDK for Processing. L'esempio seguente mostra un flusso di lavoro generale per l'utilizzo di una classe `ScriptProcessor` con il proprio container di elaborazione. Il flusso di lavoro mostra come creare la tua immagine, creare il container e utilizzare una classe `ScriptProcessor` per eseguire uno script di preelaborazione Python con il container. Il processo di elaborazione elabora i dati di input e salva i dati elaborati in Amazon Simple Storage Service (Amazon S3). Prima di utilizzare i seguenti esempi, devi disporre dei tuoi dati di input e di uno script Python preparato per elaborare i dati. Per un esempio guidato di questo processo end-to-end, fai riferimento al taccuino di esempio [scikit-learn Processing](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation). 1. Creare una directory Docker e aggiungere il file Docker utilizzato per creare il container di elaborazione. Installare panda e scikit-learn. È anche possibile installare le dipendenze con un comando `RUN` simile. ``` mkdir docker %%writefile docker/Dockerfile FROM python:3.7-slim-buster RUN pip3 install pandas==0.25.3 scikit-learn==0.21.3 ENV PYTHONUNBUFFERED=TRUE ENTRYPOINT ["python3"] ``` 1. Creare il container utilizzando il comando docker che crea un repository Amazon Elastic Container Registry (Amazon ECR) e invia l'immagine ad Amazon ECR. ``` import boto3 account_id = boto3.client('sts').get_caller_identity().get('Account') region = boto3.Session().region_name ecr_repository = 'sagemaker-processing-container' tag = ':latest' processing_repository_uri = '{}.dkr.ecr.{}.amazonaws.com/{}'.format(account_id, region, ecr_repository + tag) # Create ECR repository and push docker image !docker build -t $ecr_repository docker !aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin {account_id}.dkr.ecr.{region}.amazonaws.com !aws ecr create-repository --repository-name $ecr_repository !docker tag {ecr_repository + tag} $processing_repository_uri !docker push $processing_repository_uri ``` 1. Configura l'SDK `ScriptProcessor` di SageMaker Python per eseguire lo script. Sostituisci *image\$1uri* con l'URI dell'immagine che hai creato e sostituiscilo *role\$1arn* con l'ARN per un AWS Identity and Access Management ruolo che ha accesso al bucket Amazon S3 di destinazione. ``` from sagemaker.processing import ScriptProcessor, ProcessingInput, ProcessingOutput script_processor = ScriptProcessor(command=['python3'], image_uri='image_uri', role='role_arn', instance_count=1, instance_type='ml.m5.xlarge') ``` 1. Eseguire lo script. Sostituiscilo *preprocessing.py* con il nome del tuo script di elaborazione Python e sostituiscilo *s3://path/to/my/input-data.csv* con il percorso Amazon S3 dei tuoi dati di input. ``` script_processor.run(code='preprocessing.py', inputs=[ProcessingInput( source='s3://path/to/my/input-data.csv', destination='/opt/ml/processing/input')], outputs=[ProcessingOutput(source='/opt/ml/processing/output/train'), ProcessingOutput(source='/opt/ml/processing/output/validation'), ProcessingOutput(source='/opt/ml/processing/output/test')]) ``` La stessa procedura può essere utilizzata con qualsiasi altra libreria o dipendenza di sistema. È anche possibile utilizzare immagini Docker esistenti. Ciò include le immagini eseguite su altre piattaforme come [Kubernetes](https://kubernetes.io/). # Come creare un container di elaborazione personalizzato (scenario avanzato) Puoi fornire ad Amazon SageMaker Processing un'immagine Docker con il tuo codice e le tue dipendenze per eseguire i carichi di lavoro di elaborazione dei dati, ingegneria delle funzionalità e valutazione dei modelli. Di seguito vengono fornite informazioni su come creare un container di elaborazione personalizzato. Il seguente esempio di file Docker crea un container con le librerie Python scikit-learn e panda che è possibile eseguire come attività di elaborazione. ``` FROM python:3.7-slim-buster # Install scikit-learn and pandas RUN pip3 install pandas==0.25.3 scikit-learn==0.21.3 # Add a Python script and configure Docker to run it ADD processing_script.py / ENTRYPOINT ["python3", "/processing_script.py"] ``` Per un esempio di script di elaborazione, consulta [Get started](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_processing/basic_sagemaker_data_processing/basic_sagemaker_processing.ipynb) with Processing. SageMaker Crea e invia questa immagine Docker in un repository Amazon Elastic Container Registry (Amazon ECR) e assicurati che il tuo ruolo IAM SageMaker AI possa estrarre l'immagine da Amazon ECR. Quindi puoi eseguire questa immagine su Amazon SageMaker Processing. # In che modo Amazon SageMaker Processing esegue l'immagine del tuo contenitore di elaborazione Amazon SageMaker Processing esegue l'immagine del contenitore di elaborazione in modo simile al seguente comando, dove si `AppSpecification.ImageUri` trova l'URI dell'immagine Amazon ECR specificato in un'`CreateProcessingJob`operazione. ``` docker run [AppSpecification.ImageUri] ``` Questo comando esegue il comando `ENTRYPOINT` configurato nell'immagine Docker. È inoltre possibile sovrascrivere il comando entrypoint nell'immagine o fornire argomenti della riga di comando al comando entrypoint utilizzando i parametri `AppSpecification.ContainerEntrypoint` e `AppSpecification.ContainerArgument` nella richiesta `CreateProcessingJob`. La specificazione di questi parametri configura Amazon SageMaker Processing per eseguire il contenitore in modo simile al comando seguente. ``` docker run --entry-point [AppSpecification.ContainerEntrypoint] [AppSpecification.ImageUri] [AppSpecification.ContainerArguments] ``` Ad esempio, se specifichi `ContainerEntrypoint` to be `[python3, -v, /processing_script.py]` nella tua `CreateProcessingJob ` richiesta e `ContainerArguments` to be`[data-format, csv]`, Amazon SageMaker Processing esegue il contenitore con il seguente comando. ``` python3 -v /processing_script.py data-format csv ``` Quando si costruisce il container di elaborazione, tieni presenti i seguenti dettagli: + Amazon SageMaker Processing decide se il processo viene completato o meno in base al codice di uscita del comando eseguito. Un'attività di elaborazione viene completata se tutti i container di elaborazione escono correttamente con un codice di uscita pari a 0 e non riesce se uno dei container esce con un codice di uscita diverso da zero. + Amazon SageMaker Processing ti consente di sovrascrivere il punto di ingresso del contenitore di elaborazione e impostare argomenti della riga di comando proprio come puoi fare con l'API Docker. Le immagini Docker possono anche configurare gli argomenti dell'entrypoint e della riga di comando utilizzando le istruzioni `ENTRYPOINT` e CMD. Il modo in cui i parametri `ContainerEntrypoint` e `ContainerArgument` di `CreateProcessingJob` configurano l'entrypoint e gli argomenti di un'immagine Docker rispecchia il modo in cui Docker sovrascrive l'entrypoint e gli argomenti attraverso l'API Docker: + Se non vengono forniti né `ContainerEntrypoint` né `ContainerArguments`, Processing utilizza l'`ENTRYPOINT` o il CMD predefinito nell'immagine. + Se viene fornito `ContainerEntrypoint`, ma non `ContainerArguments`, Processing esegue l'immagine con il punto di ingresso specificato e ignora l'`ENTRYPOINT` e il CMD nell'immagine. + Se viene fornito `ContainerArguments`, ma non `ContainerEntrypoint`, Processing esegue l'immagine con l'`ENTRYPOINT` predefinito nell'immagine e con gli argomenti forniti. + Se vengono forniti sia `ContainerEntrypoint` sia `ContainerArguments`, Processing esegue l'immagine con l'entrypoint e gli argomenti specificati e ignora l'`ENTRYPOINT` e il CMD nell'immagine. + Utilizza il modulo exec dell'istruzione `ENTRYPOINT` nel Dockerfile (`ENTRYPOINT` `["executable", "param1", "param2"])` invece del modulo shell (`ENTRYPOINT`` command param1 param2`). Ciò consente al container di elaborazione di ricevere segnali `SIGINT` e `SIGKILL`, che Processing utilizza per interrompere le attività di elaborazione utilizzando l'API `StopProcessingJob`. + `/opt/ml`e tutte le sue sottodirectory sono riservate dall'IA. SageMaker Quando si crea l'immagine Docker di elaborazione, non inserire i dati richiesti dal container di elaborazione in queste directory. + Se si prevede di utilizzare dispositivi GPU, assicurarsi che i container siano compatibili con nvidia-docker. Includi solo il toolkit CUDA nei container. Non aggregare i driver NVIDIA con l'immagine. Per ulteriori informazioni su nvidia-docker, consulta [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker). # In che modo Amazon SageMaker Processing configura input e output per il tuo contenitore di elaborazione Quando crei un'attività di elaborazione utilizzando l'operazione `CreateProcessingJob`, puoi specificare più valori `ProcessingInput` e `ProcessingOutput`. Usi il parametro `ProcessingInput` per specificare un URI Amazon Simple Storage Service (Amazon S3) da cui scaricare i dati e un percorso nel container di elaborazione per scaricare i dati. Il parametro `ProcessingOutput` configura un percorso nel container di elaborazione da cui caricare i dati e il percorso in Amazon S3 dove caricare tali dati. Per entrambi `ProcessingInput` e `ProcessingOutput`, il percorso nel container di elaborazione deve iniziare con `/opt/ml/processing/ `. Ad esempio, puoi creare un'attività di elaborazione con un parametro `ProcessingInput` che scarica i dati da un percorso `s3://your-data-bucket/path/to/input/csv/data` in un percorso `/opt/ml/processing/csv` del container di elaborazione e un parametro `ProcessingOutput` che carica i dati da `/opt/ml/processing/processed_csv` in `s3://your-data-bucket/path/to/output/csv/data`. Il processo di elaborazione legge i dati di input e scrive i dati di output in `/opt/ml/processing/processed_csv`. Quindi carica i dati scritti in questo percorso nella posizione di output Amazon S3 specificata. **Importante** I link simbolici (symlinks) non possono essere utilizzati per caricare dati di output su Amazon S3. I link simbolici non vengono seguiti durante il caricamento dei dati di output. # In che modo Amazon SageMaker Processing fornisce log e parametri per il tuo contenitore di elaborazione Quando il container di elaborazione scrive su `stdout` o`stderr`, Amazon SageMaker Processing salva l'output di ogni contenitore di elaborazione e lo inserisce nei CloudWatch log di Amazon. Per ulteriori informazioni sulla registrazione, consulta [CloudWatch Registri per Amazon SageMaker AI](logging-cloudwatch.md). Amazon SageMaker Processing fornisce anche CloudWatch parametri per ogni istanza che esegue il container di elaborazione. Per ulteriori informazioni sui parametri, consulta [Metriche di Amazon SageMaker AI in Amazon CloudWatch](monitoring-cloudwatch.md). ## In che modo Amazon SageMaker Processing configura il tuo contenitore di elaborazione Amazon SageMaker Processing fornisce informazioni di configurazione al contenitore di elaborazione tramite variabili di ambiente e due file JSON `/opt/ml/config/processingjobconfig.json` e `/opt/ml/config/resourceconfig.json` in posizioni predefinite all'interno del contenitore. Quando viene avviato un processo di elaborazione, vengono utilizzate le variabili di ambiente specificate con la mappa `Environment` nella richiesta `CreateProcessingJob`. Il file `/opt/ml/config/processingjobconfig.json` contiene le informazioni sui nomi host dei container di elaborazione ed è specificato anche nella richiesta `CreateProcessingJob`. Nell'esempio seguente viene illustrato il formato del file `/opt/ml/config/processingjobconfig.json`. ``` { "ProcessingJobArn": "", "ProcessingJobName": "", "AppSpecification": { "ImageUri": "", "ContainerEntrypoint": null, "ContainerArguments": null }, "Environment": { "KEY": "VALUE" }, "ProcessingInputs": [ { "InputName": "input-1", "S3Input": { "LocalPath": "/opt/ml/processing/input/dataset", "S3Uri": "", "S3DataDistributionType": "FullyReplicated", "S3DataType": "S3Prefix", "S3InputMode": "File", "S3CompressionType": "None", "S3DownloadMode": "StartOfJob" } } ], "ProcessingOutputConfig": { "Outputs": [ { "OutputName": "output-1", "S3Output": { "LocalPath": "/opt/ml/processing/output/dataset", "S3Uri": "", "S3UploadMode": "EndOfJob" } } ], "KmsKeyId": null }, "ProcessingResources": { "ClusterConfig": { "InstanceCount": 1, "InstanceType": "ml.m5.xlarge", "VolumeSizeInGB": 30, "VolumeKmsKeyId": null } }, "RoleArn": "", "StoppingCondition": { "MaxRuntimeInSeconds": 86400 } } ``` Il file `/opt/ml/config/resourceconfig.json` contiene informazioni sui nomi host dei container di elaborazione. Utilizza i seguenti nomi host durante la creazione o l'esecuzione di codice di elaborazione distribuito. ``` { "current_host": "algo-1", "hosts": ["algo-1","algo-2","algo-3"] } ``` Non utilizzare le informazioni sui nomi host contenuti in `/etc/hostname` o `/etc/hosts` perché potrebbero non essere accurate. Le informazioni sul nome host potrebbero non essere immediatamente disponibili per il container di elaborazione. Ti consigliamo di aggiungere una policy per i nuovi tentativi sulle operazioni di risoluzione del nome host man mano che i nodi diventano disponibili nel cluster. # Salvare e accedere alle informazioni dei metadati sul processo di elaborazione Per salvare i metadati dal container di elaborazione una volta chiuso, i container possono scrivere testo codificato UTF-8 nel file `/opt/ml/output/message`. Quando il processo di elaborazione passa a uno stato del terminale ("`Completed`", "`Stopped`" o "`Failed`"), il campo "`ExitMessage`" in [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html) contiene il primo 1 KB di questo file. Accedi a quella parte iniziale del file con una chiamata a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html), che la restituisce attraverso il parametro `ExitMessage`. Per le attività di elaborazione non riuscite, puoi utilizzare questo campo per comunicare informazioni sul perché il container di elaborazione non è riuscito. **Importante** Non scrivere dati sensibili nel file `/opt/ml/output/message`. Se i dati in questo file non sono codificati UTF-8, il processo non riesce e viene restituito un `ClientError`. Se più container vengono chiusi con un `ExitMessage,`, il contenuto di `ExitMessage` di ciascun container di elaborazione viene concatenato, quindi troncato a 1 KB. # Esegui il tuo contenitore di elaborazione utilizzando l' SageMaker SDK AI Python Puoi usare SageMaker Python SDK per eseguire la tua immagine di elaborazione utilizzando la classe. `Processor` L'esempio seguente mostra come eseguire il container di elaborazione con un input da Amazon Simple Storage Service (Amazon S3) e un output in Amazon S3. ``` from sagemaker.processing import Processor, ProcessingInput, ProcessingOutput processor = Processor(image_uri='', role=role, instance_count=1, instance_type="ml.m5.xlarge") processor.run(inputs=[ProcessingInput( source='', destination='/opt/ml/processing/input_data')], outputs=[ProcessingOutput( source='/opt/ml/processing/processed_data', destination='')], ) ``` Invece di creare il codice di elaborazione nell'immagine di elaborazione, puoi fornire uno `ScriptProcessor` con la tua immagine e il comando che vuoi eseguire, insieme al codice da eseguire all'interno di quel container. Per vedere un esempio, consulta [Eseguire script con il proprio container di elaborazione](processing-container-run-scripts.md). Puoi anche usare l'immagine scikit-learn fornita da Amazon SageMaker Processing `SKLearnProcessor` per eseguire script scikit-learn. Per un esempio, consulta [Eseguire un processo Processing con scikit-learn](use-scikit-learn-processing-container.md).