Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Workloads zur Datentransformation mit SageMaker Verarbeitung SageMaker Verarbeitung bezieht sich auf die Fähigkeiten von SageMaker KI, Aufgaben zur Datenvor- und Nachverarbeitung, Feature-Engineering und Modellevaluierung in der vollständig verwalteten SageMaker KI-Infrastruktur auszuführen. Diese Aufgaben werden als [Verarbeitungsjobs](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProcessingJob.html) ausgeführt. Im Folgenden finden Sie Informationen und Ressourcen, um mehr über die SageMaker Verarbeitung zu erfahren. Mithilfe der SageMaker Processing API können Datenwissenschaftler Skripte und Notizbücher ausführen, um Datensätze zu verarbeiten, zu transformieren und zu analysieren, um sie für maschinelles Lernen vorzubereiten. In Kombination mit den anderen wichtigen Aufgaben des maschinellen Lernens, die von SageMaker KI bereitgestellt werden, wie Schulung und Hosting, bietet Ihnen Processing die Vorteile einer vollständig verwalteten Umgebung für maschinelles Lernen, einschließlich der gesamten in SageMaker KI integrierten Sicherheits- und Compliance-Unterstützung. Sie haben die Flexibilität, die integrierten Datenverarbeitungscontainer zu verwenden oder Ihre eigenen Container für die benutzerdefinierte Verarbeitungslogik zu verwenden und dann Jobs zur Ausführung auf einer SageMaker KI-verwalteten Infrastruktur einzureichen. **Anmerkung** Sie können einen Verarbeitungsauftrag programmgesteuert erstellen, indem Sie die [CreateProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html)API-Aktion in einer beliebigen von SageMaker KI unterstützten Sprache aufrufen oder indem Sie den verwenden. AWS CLI Informationen dazu, wie diese API-Aktion in eine Funktion in der Sprache Ihrer Wahl übersetzt wird, finden Sie im Abschnitt „[Siehe auch](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateProcessingJob.html#API_CreateProcessingJob_SeeAlso)“ von CreateProcessingJob und wählen Sie ein SDK aus. Ein Beispiel für Python-Benutzer finden Sie im Abschnitt [Amazon SageMaker Processing](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_processing.html) des SageMaker Python-SDK. Alternativ finden Sie die vollständige Anforderungssyntax von [create\$1processing\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_processing_job.html) in AWS SDK für Python (Boto3). Das folgende Diagramm zeigt, wie Amazon SageMaker AI einen Verarbeitungsjob auslöst. Amazon SageMaker AI nimmt Ihr Skript, kopiert Ihre Daten aus Amazon Simple Storage Service (Amazon S3) und ruft dann einen Verarbeitungscontainer ab. Die zugrunde liegende Infrastruktur für einen Verarbeitungsauftrag wird vollständig von Amazon SageMaker AI verwaltet. Nachdem Sie einen Verarbeitungsauftrag eingereicht haben, startet SageMaker KI die Compute-Instances, verarbeitet und analysiert die Eingabedaten und gibt die Ressourcen nach Abschluss frei. Die Ausgabe des Processing-Auftrages wird im Amazon-S3-Bucket gespeichert, den Sie angegeben haben. **Anmerkung** Die Eingabedaten müssen in einem Amazon-S3-Bucket gespeichert sein. Alternativ können Sie Amazon Athena oder Amazon Redshift als Eingabequellen verwenden. ![\[Ausführen eines Verarbeitungsauftrags.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/Processing-1.png) **Tipp** Bewährte Methoden für verteiltes Rechnen für Training und Verarbeitung von Machine Learning (ML) im Allgemeinen finden Sie unter [Verteiltes Rechnen mit Best Practices für SageMaker KI](distributed-training-options.md). ## Verwenden Sie Amazon SageMaker Processing Sample Notebooks Anhand von zwei Beispiel-Jupyter-Notebooks zeigen wir, wie Datenvorverarbeitung, Modellauswertung oder beides durchgeführt werden. [Ein Beispielnotizbuch, das zeigt, wie Scikit-Learn-Skripte ausgeführt werden, um Datenvorverarbeitung und Modelltraining und -auswertung mit dem SageMaker Python-SDK for Processing durchzuführen, finden Sie unter scikit-learn Processing.](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation) In diesem Notebook wird auch gezeigt, wie Sie einen eigenen benutzerdefinierten Container verwenden, um Verarbeitungslasten mit Python-Bibliotheken und anderen spezifischen Abhängigkeiten auszuführen. Ein Beispielnotizbuch, das zeigt, wie Amazon SageMaker Processing für die verteilte Datenvorverarbeitung mit Spark verwendet wird, finden Sie unter [Distributed Processing (Spark)](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_processing/spark_distributed_data_processing/sagemaker-spark-processing.ipynb). Dieses Notizbuch zeigt auch, wie ein Regressionsmodell XGBoost anhand des vorverarbeiteten Datensatzes trainiert wird. Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instanzen, mit denen Sie diese Beispiele in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie die Registerkarte **SageMaker KI-Beispiele**, um eine Liste aller KI-Beispiele anzuzeigen. SageMaker Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Verwenden** und dann **Kopie erstellen** aus. ## Überwachen Sie SageMaker Amazon-Verarbeitungsaufträge mit CloudWatch Protokollen und Metriken Amazon SageMaker Processing stellt CloudWatch Amazon-Protokolle und -Metriken zur Überwachung von Verarbeitungsaufträgen bereit. CloudWatch bietet Metriken zu CPU, GPU, Arbeitsspeicher, GPU-Speicher und Festplatte sowie Ereignisprotokollierung. Weitere Informationen erhalten Sie unter [SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md) und [CloudWatch Protokolle für Amazon SageMaker AI](logging-cloudwatch.md). # Ausführen eines Verarbeitungsjobs mit Apache Spark Apache Spark ist eine einheitliche Analyse-Engine für die Datenverarbeitung in großem Maßstab. Amazon SageMaker AI bietet vorgefertigte Docker-Images, die Apache Spark und andere Abhängigkeiten enthalten, die für die Ausführung verteilter Datenverarbeitungsaufträge erforderlich sind. Im Folgenden finden Sie ein Beispiel für die Ausführung eines Jobs von Amazon SageMaker Processing mit Apache Spark. Mit dem [Amazon SageMaker Python SDK](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk) können Sie mithilfe des Spark-Frameworks auf einfache Weise Datentransformationen und Extraktionsfunktionen (Feature-Engineering) anwenden. Informationen zur Verwendung des SageMaker Python SDK zur Ausführung von Spark-Verarbeitungsaufträgen finden Sie unter [Datenverarbeitung mit Spark](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_processing.html#data-processing-with-spark) im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/). Ein Code-Repository, das den Quellcode und die Dockerfiles für die Spark-Images enthält, ist auf [GitHub](https://github.com/aws/sagemaker-spark-container) verfügbar. Sie können die [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) oder [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) Klasse verwenden, um Ihre Spark-Anwendung innerhalb eines Verarbeitungsauftrages auszuführen. Beachten Sie, dass Sie MaxRuntimeInSeconds auf ein maximales Laufzeitlimit von 5 Tagen setzen können. In Bezug auf die Ausführungszeit und die Anzahl der verwendeten Instances besteht bei einfachen Spark-Workloads ein nahezu lineares Verhältnis zwischen der Anzahl der Instances und der Zeit bis zur Fertigstellung. Das folgende Codebeispiel veranschaulicht, wie ein Verarbeitungsauftrag ausgeführt wird, der Ihr PySpark-Skript `preprocess.py` aufruft. ``` 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] ) ``` Einen ausführlichen Einblick finden Sie im [Beispiel-Notebook](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_processing/spark_distributed_data_processing/sagemaker-spark-processing.html) Distributed Data Processing with Apache Spark and SageMaker Processing. Wenn Sie das [Amazon SageMaker AI Python SDK](https://sagemaker.readthedocs.io/) und eine seiner Prozessorklassen nicht zum Abrufen der vorgefertigten Images verwenden, können Sie diese Images selbst abrufen. Die vorgefertigten Regel-Docker-Images von Amazon SageMaker werden in der Amazon Elastic Container Registry (Amazon ECR) gespeichert. Eine vollständige Liste der verfügbaren vorgefertigten Docker-Images finden Sie im Dokument [Verfügbare Images](https://github.com/aws/sagemaker-spark-container/blob/master/available_images.md). Weitere Informationen zur Verwendung des SageMaker Python SDK mit Verarbeitungscontainern finden Sie unter [Amazon SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/). # Ausführen eines Verarbeitungsjobs mit scikit-learn Sie können Amazon SageMaker Processing verwenden, um Daten zu verarbeiten und Modelle mit scikit-learn-Skripten in einem von Amazon SageMaker AI bereitgestellten Docker-Image auszuwerten. Im Folgenden finden Sie ein Beispiel für die Ausführung eines Jobs von Amazon SageMaker Processing mit Scikit-Learn. Ein Beispiel-Notebook, das zeigt, wie scikit-learn-Skripte mit einem Docker-Image ausgeführt werden, das von SageMaker AI zur Vorverarbeitung von Daten und Auswertung von Modellen bereitgestellt und verwaltet wird, finden Sie unter [scikit-learn-Verarbeitung](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation). Um dieses Notebook zu verwenden, müssen Sie das SageMaker AI Python SDK für die Verarbeitung installieren. Dieses Notebook führt einen Verarbeitungsauftrag aus, der die `SKLearnProcessor` Klasse aus dem SageMaker Python-SDK für Python verwendet, um ein von Ihnen bereitgestelltes scikit-learn-Skript auszuführen. Das Skript verarbeitet Daten vorab, schult ein Modell mithilfe eines SageMaker-Trainingsauftrags und führt dann einen Verarbeitungsauftrag aus, um das trainierte Modell auszuwerten. Mit dem Verarbeitungsauftrag wird die Leistung des Modells in der Produktion geschätzt. Weitere Informationen zur Verwendung des SageMaker Python SDK mit Verarbeitungscontainern finden Sie unter [SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/). Eine vollständige Liste der vorgefertigten Docker-Images, die für die Verarbeitung von Aufträgen verfügbar sind, finden Sie unter [Docker-Registry-Pfade und Beispielcode](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths). Das folgende Beispiel zeigt, wie Notebook `SKLearnProcessor` verwendet, um Ihr eigenes scikit-learn-Skript mit einem von SageMaker AI bereitgestellten und verwalteten Docker-Image, anstatt Ihrem eigenen Docker-Image, auszuführen. ``` 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')] ) ``` Um Daten parallel mit Scikit-Learn on Amazon SageMaker Processing zu verarbeiten, können Sie Eingabeobjekte nach S3-Schlüssel freigeben, indem Sie `s3_data_distribution_type='ShardedByS3Key'` innerhalb eines `ProcessingInput` so festlegen, dass jede Instance ungefähr die gleiche Anzahl von Eingabeobjekten empfängt. # Datenverarbeitung mit Framework-Prozessoren A `FrameworkProcessor` kann Verarbeitungsjobs mit einem bestimmten Machine Learning-Framework ausführen und stellt Ihnen einen von Amazon SageMaker AI verwalteten Container für das von Ihnen gewählte Machine Learning-Framework zur Verfügung. `FrameworkProcessor`bietet vorgefertigte Container für die folgenden Frameworks für maschinelles Lernen: Hugging Face,, MXNet PyTorch, TensorFlow und. XGBoost Die `FrameworkProcessor` Klasse bietet Ihnen auch die Möglichkeit, die Container-Konfiguration anzupassen. Die `FrameworkProcessor` Klasse unterstützt die Angabe eines Quellverzeichnisses `source_dir` für Ihre Verarbeitungsskripten und Abhängigkeiten. Mit dieser Funktion können Sie dem Prozessor Zugriff auf mehrere Skripten in einem Verzeichnis gewähren, anstatt nur ein Skript anzugeben. `FrameworkProcessor` unterstützt auch das Einfügen einer `requirements.txt` Datei in die `source_dir` zum Anpassen der Python-Bibliotheken, die im Container installiert werden sollen. Weitere Informationen zur `FrameworkProcessor` Klasse und ihren Methoden und Parametern finden Sie [FrameworkProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.processing.FrameworkProcessor)im *Amazon SageMaker AI Python SDK*. Beispiele für die Verwendung von a `FrameworkProcessor` für jedes der unterstützten Frameworks für Machine Learning finden Sie in den folgenden Themen. **Topics** + [Codebeispiel für die Verwendung HuggingFaceProcessor im Amazon SageMaker Python SDK](processing-job-frameworks-hugging-face.md) + [MXNet Framework-Prozessor](processing-job-frameworks-mxnet.md) + [PyTorch Framework-Prozessor](processing-job-frameworks-pytorch.md) + [TensorFlow Framework-Prozessor](processing-job-frameworks-tensorflow.md) + [XGBoost Framework-Prozessor](processing-job-frameworks-xgboost.md) # Codebeispiel für die Verwendung HuggingFaceProcessor im Amazon SageMaker Python SDK Hugging Face ist ein Open-Source-Anbieter von Modellen zur natürlichen Sprachverarbeitung (NLP). Das `HuggingFaceProcessor` im Amazon SageMaker Python SDK enthaltene SDK bietet Ihnen die Möglichkeit, Verarbeitungsjobs mit Hugging Face Face-Skripten auszuführen. Wenn Sie den `HuggingFaceProcessor` verwenden, können Sie einen von Amazon erstellten Docker-Container mit einer verwalteten Hugging Face-Umgebung nutzen, sodass Sie keinen eigenen Container mitbringen müssen. Das folgende Codebeispiel zeigt, wie Sie den verwenden können, `HuggingFaceProcessor` um Ihren Processing-Job mithilfe eines von AI bereitgestellten und verwalteten Docker-Images auszuführen. SageMaker Beachten Sie, dass Sie bei der Ausführung des Jobs ein Verzeichnis mit Ihren Skripten und Abhängigkeiten im `source_dir` Argument angeben können und dass sich in Ihrem `source_dir` Verzeichnis eine `requirements.txt` Datei befinden kann, die die Abhängigkeiten für Ihre Verarbeitungsskripte angibt. SageMaker Bei der Verarbeitung werden die Abhängigkeiten für Sie `requirements.txt` im Container installiert. ``` 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}') ] ) ``` Wenn Sie eine `requirements.txt` Datei haben, sollte es sich um eine Liste von Bibliotheken handeln, die Sie im Container installieren möchten. Der Pfad für `source_dir` kann ein relativer, absoluter oder Amazon-S3-URI-Pfad sein. Wenn Sie jedoch einen Amazon-S3-URI verwenden, muss dieser auf eine Datei tar.gz verweisen. Sie können mehrere Skripte in dem Verzeichnis haben, das Sie für `source_dir` angeben. Weitere Informationen zu diesem `HuggingFaceProcessor` Kurs finden Sie unter [Hugging Face Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html) im *Amazon SageMaker AI* Python SDK. # MXNet Framework-Prozessor Apache MXNet ist ein Open-Source-Deep-Learning-Framework, das häufig für das Training und den Einsatz neuronaler Netzwerke verwendet wird. Das `MXNetProcessor` im Amazon SageMaker Python SDK enthaltene SDK bietet Ihnen die Möglichkeit, Verarbeitungsaufträge mit MXNet Skripten auszuführen. Wenn Sie den verwenden`MXNetProcessor`, können Sie einen von Amazon erstellten Docker-Container mit einer verwalteten MXNet Umgebung nutzen, sodass Sie keinen eigenen Container mitbringen müssen. Das folgende Codebeispiel zeigt, wie Sie den verwenden können`MXNetProcessor`, um Ihren Verarbeitungsjob mithilfe eines von AI bereitgestellten und verwalteten Docker-Images auszuführen. SageMaker Beachten Sie, dass Sie bei der Ausführung des Jobs ein Verzeichnis mit Ihren Skripten und Abhängigkeiten im `source_dir` Argument angeben können und dass sich in Ihrem `source_dir` Verzeichnis eine `requirements.txt` Datei befinden kann, die die Abhängigkeiten für Ihre Verarbeitungsskripte angibt. SageMaker Bei der Verarbeitung werden die Abhängigkeiten für Sie `requirements.txt` im Container installiert. ``` 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}' ) ] ) ``` Wenn Sie eine `requirements.txt` Datei haben, sollte es sich um eine Liste von Bibliotheken handeln, die Sie im Container installieren möchten. Der Pfad für `source_dir` kann ein relativer, absoluter oder Amazon-S3-URI-Pfad sein. Wenn Sie jedoch einen Amazon-S3-URI verwenden, muss dieser auf eine Datei tar.gz verweisen. Sie können mehrere Skripte in dem Verzeichnis haben, das Sie für `source_dir` angeben. Weitere Informationen zu der `MXNetProcessor` Klasse finden Sie unter [MXNet Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html#mxnet-estimator) im *Amazon SageMaker Python SDK*. # PyTorch Framework-Prozessor PyTorch ist ein Open-Source-Framework für maschinelles Lernen. Das `PyTorchProcessor` im Amazon SageMaker Python SDK enthaltene SDK bietet Ihnen die Möglichkeit, Verarbeitungsaufträge mit PyTorch Skripten auszuführen. Wenn Sie den verwenden`PyTorchProcessor`, können Sie einen von Amazon erstellten Docker-Container mit einer verwalteten PyTorch Umgebung nutzen, sodass Sie keinen eigenen Container mitbringen müssen. Das folgende Codebeispiel zeigt, wie Sie den verwenden können`PyTorchProcessor`, um Ihren Verarbeitungsjob mithilfe eines von AI bereitgestellten und verwalteten Docker-Images auszuführen. SageMaker Beachten Sie, dass Sie bei der Ausführung des Jobs ein Verzeichnis mit Ihren Skripten und Abhängigkeiten im `source_dir` Argument angeben können und dass sich in Ihrem `source_dir` Verzeichnis eine `requirements.txt` Datei befinden kann, die die Abhängigkeiten für Ihre Verarbeitungsskripte angibt. SageMaker Bei der Verarbeitung werden die Abhängigkeiten für Sie `requirements.txt` im Container installiert. Die von SageMaker AI unterstützten PyTorch Versionen finden Sie in den verfügbaren [Deep Learning-Container-Images](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}') ] ) ``` Wenn Sie eine `requirements.txt` Datei haben, sollte es sich um eine Liste von Bibliotheken handeln, die Sie im Container installieren möchten. Der Pfad für `source_dir` kann ein relativer, absoluter oder Amazon-S3-URI-Pfad sein. Wenn Sie jedoch einen Amazon-S3-URI verwenden, muss dieser auf eine Datei tar.gz verweisen. Sie können mehrere Skripte in dem Verzeichnis haben, das Sie für `source_dir` angeben. Weitere Informationen zu der `PyTorchProcessor` Klasse finden Sie unter [PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html) im *Amazon SageMaker Python SDK*. # TensorFlow Framework-Prozessor TensorFlow ist eine Open-Source-Bibliothek für maschinelles Lernen und künstliche Intelligenz. Das `TensorFlowProcessor` im Amazon SageMaker Python SDK enthaltene SDK bietet Ihnen die Möglichkeit, Verarbeitungsaufträge mit TensorFlow Skripten auszuführen. Wenn Sie den verwenden`TensorFlowProcessor`, können Sie einen von Amazon erstellten Docker-Container mit einer verwalteten TensorFlow Umgebung nutzen, sodass Sie keinen eigenen Container mitbringen müssen. Das folgende Codebeispiel zeigt, wie Sie den verwenden können`TensorFlowProcessor`, um Ihren Verarbeitungsjob mithilfe eines von AI bereitgestellten und verwalteten Docker-Images auszuführen. SageMaker Beachten Sie, dass Sie bei der Ausführung des Jobs ein Verzeichnis mit Ihren Skripten und Abhängigkeiten im `source_dir` Argument angeben können und dass sich in Ihrem `source_dir` Verzeichnis eine `requirements.txt` Datei befinden kann, die die Abhängigkeiten für Ihre Verarbeitungsskripte angibt. SageMaker Bei der Verarbeitung werden die Abhängigkeiten für Sie `requirements.txt` im Container installiert. ``` 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}' ) ] ) ``` Wenn Sie eine `requirements.txt` Datei haben, sollte es sich um eine Liste von Bibliotheken handeln, die Sie im Container installieren möchten. Der Pfad für `source_dir` kann ein relativer, absoluter oder Amazon-S3-URI-Pfad sein. Wenn Sie jedoch einen Amazon-S3-URI verwenden, muss dieser auf eine Datei tar.gz verweisen. Sie können mehrere Skripte in dem Verzeichnis haben, das Sie für `source_dir` angeben. Weitere Informationen zu der `TensorFlowProcessor` Klasse finden Sie unter [TensorFlow Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) im *Amazon SageMaker Python SDK*. # XGBoost Framework-Prozessor XGBoost ist ein Open-Source-Framework für maschinelles Lernen. Das `XGBoostProcessor` im Amazon SageMaker Python SDK enthaltene SDK bietet Ihnen die Möglichkeit, Verarbeitungsaufträge mit XGBoost Skripten auszuführen. Wenn Sie den XGBoost Prozessor verwenden, können Sie einen von Amazon erstellten Docker-Container mit einer verwalteten XGBoost Umgebung nutzen, sodass Sie keinen eigenen Container mitbringen müssen. Das folgende Codebeispiel zeigt, wie Sie den verwenden können`XGBoostProcessor`, um Ihren Verarbeitungsjob mithilfe eines von AI bereitgestellten und verwalteten Docker-Images auszuführen. SageMaker Beachten Sie, dass Sie bei der Ausführung des Jobs ein Verzeichnis mit Ihren Skripten und Abhängigkeiten im `source_dir` Argument angeben können und dass sich in Ihrem `source_dir` Verzeichnis eine `requirements.txt` Datei befinden kann, die die Abhängigkeiten für Ihre Verarbeitungsskripte angibt. SageMaker Bei der Verarbeitung werden die Abhängigkeiten für Sie `requirements.txt` im Container installiert. ``` 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}' ) ] ) ``` Wenn Sie eine `requirements.txt` Datei haben, sollte es sich um eine Liste von Bibliotheken handeln, die Sie im Container installieren möchten. Der Pfad für `source_dir` kann ein relativer, absoluter oder Amazon-S3-URI-Pfad sein. Wenn Sie jedoch einen Amazon-S3-URI verwenden, muss dieser auf eine Datei tar.gz verweisen. Sie können mehrere Skripte in dem Verzeichnis haben, das Sie für `source_dir` angeben. Weitere Informationen zu der `XGBoostProcessor` Klasse finden Sie unter [XGBoost Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/xgboost/xgboost.html) im *Amazon SageMaker Python SDK*. # Verwenden Ihres eigenen Verarbeitungscodes Sie können Bibliotheken installieren, um Ihre Skripts in Ihrem eigenen Verarbeitungscontainer auszuführen, oder in einem fortgeschritteneren Szenario können Sie Ihren eigenen Verarbeitungscontainer erstellen, der den Vertrag zur Ausführung in Amazon SageMaker AI erfüllt. Weitere Informationen zu Containern in SageMaker KI finden Sie unter[Docker-Container für das Training und die Bereitstellung von Modellen](docker-containers.md). Eine formale Spezifikation, die den Vertrag für einen Amazon SageMaker Processing Container definiert, finden Sie unter[So erstellen Sie einen eigenen Verarbeitungscontainer (erweitertes Szenario)](build-your-own-processing-container.md). **Topics** + [Ausführen von Scripts mit Ihrem eigenen Verarbeitungscontainer](processing-container-run-scripts.md) + [So erstellen Sie einen eigenen Verarbeitungscontainer (erweitertes Szenario)](build-your-own-processing-container.md) # Ausführen von Scripts mit Ihrem eigenen Verarbeitungscontainer Sie können scikit-learn-Skripte verwenden, um Daten vorzuverarbeiten und Ihre Modelle auszuwerten. Um zu sehen, wie man scikit-learn Skripte ausführt, um diese Aufgaben zu erfüllen, siehe das [scikit-learn Processing](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation) Beispiel-Notebook. Dieses Notizbuch verwendet die `ScriptProcessor` Klasse aus dem Amazon SageMaker Python SDK for Processing. Das folgende Beispiel zeigt einen allgemeinen Arbeitsablauf für die Verwendung einer `ScriptProcessor` Klasse mit Ihrem eigenen Verarbeitungscontainer. Der Workflow zeigt, wie Sie Ihr eigenes Image erstellen, Ihren Container erstellen und eine `ScriptProcessor` Klasse verwenden, um ein Python-Vorverarbeitungsskript mit dem Container auszuführen. Der Verarbeitungsjob verarbeitet Ihre Eingabedaten und speichert die verarbeiteten Daten in Amazon Simple Storage Service (Amazon S3). Bevor Sie die folgenden Beispiele verwenden können, müssen Sie Ihre eigenen Eingabedaten und ein Python-Skript für die Verarbeitung Ihrer Daten vorbereitet haben. Ein end-to-end Beispiel mit Anleitungen für diesen Prozess finden Sie im [Scikit-Learn Processing Beispiel-Notizbuch](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker_processing/scikit_learn_data_processing_and_model_evaluation). 1. Erstellen Sie eine Docker-Registry und fügen Sie die Docker-Datei hinzu, die zum Erstellen des Verarbeitungscontainers verwendet wird. Installieren Sie darin Pandas und scikit-learn. (Sie können mit einem ähnlichen `RUN`-Befehl auch Ihre eigenen Abhängigkeiten installieren.) ``` 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. Erstellen Sie den Container mit dem Docker-Befehl, erstellen Sie ein Amazon Elastic Container Registry (Amazon ECR)-Repository und pushen Sie das Image zu 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. Richten Sie das `ScriptProcessor` vom SageMaker Python-SDK aus ein, um das Skript auszuführen. *image\$1uri*Ersetzen Sie durch den URI für das von Ihnen erstellte Image und durch den *role\$1arn* ARN für eine AWS Identity and Access Management Rolle, die Zugriff auf Ihren Amazon S3 S3-Ziel-Bucket hat. ``` 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. Führen Sie das Skript aus. *preprocessing.py*Ersetzen Sie es durch den Namen Ihres eigenen Python-Verarbeitungsskripts und *s3://path/to/my/input-data.csv* ersetzen Sie es durch den Amazon S3 S3-Pfad zu Ihren Eingabedaten. ``` 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')]) ``` Das gleiche Verfahren kann mit anderen Bibliotheks- oder Systemabhängigkeiten verwendet werden. Sie können auch vorhandene Docker-Images verwenden. Dazu gehören Images, die Sie auf anderen Plattformen wie [Kubernetes](https://kubernetes.io/) ausführen. # So erstellen Sie einen eigenen Verarbeitungscontainer (erweitertes Szenario) Sie können Amazon SageMaker Processing ein Docker-Image zur Verfügung stellen, das über Ihren eigenen Code und Abhängigkeiten verfügt, um Ihre Workloads für Datenverarbeitung, Feature-Engineering und Modellevaluierung auszuführen. Im Folgenden finden Sie Informationen dazu, wie Sie Ihren eigenen Verarbeitungscontainer erstellen. Im folgenden Beispiel wird mithilfe einer Docker-Datei ein Container mit den Python-Bibliotheken „scikit-learn“ und „pandas“ erstellt, den Sie als Verarbeitungsauftrag ausführen können. ``` 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"] ``` Ein Beispiel für ein Verarbeitungsskript finden Sie unter [Erste Schritte mit SageMaker ](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker_processing/basic_sagemaker_data_processing/basic_sagemaker_processing.ipynb) der Verarbeitung. Erstellen Sie dieses Docker-Image, übertragen Sie es in ein Amazon Elastic Container Registry (Amazon ECR) -Repository und stellen Sie sicher, dass Ihre SageMaker KI-IAM-Rolle das Image aus Amazon ECR abrufen kann. Dann können Sie dieses Image auf Amazon SageMaker Processing ausführen. # So führt Amazon SageMaker Processing Ihr Prozesscontainer-Image aus Amazon SageMaker Processing führt Ihr Verarbeitungscontainer-Image auf ähnliche Weise wie den folgenden Befehl aus, wobei `AppSpecification.ImageUri` es sich um den Amazon ECR-Image-URI handelt, den Sie in einem `CreateProcessingJob` Vorgang angeben. ``` docker run [AppSpecification.ImageUri] ``` Mit diesem Befehl wird der im Docker-Image konfigurierte `ENTRYPOINT`-Befehl ausgeführt. Sie können auch den Eintrittspunktbefehl im Image überschreiben oder ihm Befehlszeilenargumente mit den Parametern `AppSpecification.ContainerEntrypoint` und `AppSpecification.ContainerArgument` in Ihrer `CreateProcessingJob`-Anforderung übergeben. Durch die Angabe dieser Parameter wird Amazon SageMaker Processing so konfiguriert, dass der Container ähnlich wie der folgende Befehl ausgeführt wird. ``` docker run --entry-point [AppSpecification.ContainerEntrypoint] [AppSpecification.ImageUri] [AppSpecification.ContainerArguments] ``` Wenn Sie beispielsweise angeben, dass `[python3, -v, /processing_script.py]` in Ihrer `CreateProcessingJob ` Anfrage sein und `ContainerArguments` sein sein`[data-format, csv]`, führt Amazon SageMaker Processing Ihren Container mit dem folgenden Befehl aus. `ContainerEntrypoint` ``` python3 -v /processing_script.py data-format csv ``` Beachten Sie beim Erstellen Ihres Verarbeitungscontainers die folgenden Details: + Amazon SageMaker Processing entscheidet je nach Exit-Code der Befehlsausführung, ob der Job abgeschlossen wird oder fehlschlägt. Ein Verarbeitungsauftrag wird ausgeführt, wenn alle Verarbeitungscontainer erfolgreich mit dem Beendigungscode 0 beendet werden, und schlägt fehl, wenn einer der Container mit einem Beendigungscode ungleich Null beendet wird. + Mit Amazon SageMaker Processing können Sie den Einstiegspunkt des Verarbeitungscontainers überschreiben und Befehlszeilenargumente festlegen, genau wie Sie es mit der Docker-API tun können. Docker-Images können die Eintrittspunkt und die Befehlszeilenargumente auch unter Verwendung des `ENTRYPOINT` und der CMD-Anweisungen konfigurieren. Die Art und Weise, wie die Parameter `ContainerEntrypoint` und `ContainerArgument` des `CreateProcessingJob` den Eintrittspunkt und die Argumente eines Docker-Image konfigurieren, spiegelt wider, wie Docker den Eintrittspunkt und die Argumente über die Docker-API überschreibt: + Wenn weder `ContainerEntrypoint` noch `ContainerArguments` angegeben werden, verwendet Processing den Standard `ENTRYPOINT` oder CMD im image. + Wenn `ContainerEntrypoint` angegeben wird, aber nicht `ContainerArguments`, führt die Verarbeitung das Bild mit dem angegebenen Eintrittspunkt aus und ignoriert `ENTRYPOINT` und CMD im Bild. + Wenn `ContainerArguments`, aber nicht `ContainerEntrypoint` angegeben wird, führt Processing das Abbild mit dem Standard-`ENTRYPOINT` im Abbild und mit den angegebenen Argumenten aus. + Wenn sowohl `ContainerEntrypoint` als auch `ContainerArguments` angegeben sind, führt die Verarbeitung das Bild mit dem angegebenen Eintrittspunkt und den Argumenten aus und ignoriert `ENTRYPOINT` und CMD im Bild. + Sie müssen die exec-Form der `ENTRYPOINT`-Anweisung in Ihrem Dockerfile verwenden (`ENTRYPOINT` `["executable", "param1", "param2"])` anstelle der Shell-Form (`ENTRYPOINT`` command param1 param2`). Dadurch kann Ihr Verarbeitungscontainer – `SIGINT`und `SIGKILL`-Signale empfangen, die von der Verarbeitung zum Stoppen von Verarbeitungsaufträgen über die `StopProcessingJob`-API verwendet werden. + `/opt/ml`und all seine Unterverzeichnisse sind von AI reserviert. SageMaker Wenn Sie Ihr Processing-Docker-Image erstellen, sollten Sie keine Daten, die für Ihren Processing-Container erforderlich sind, in diesen Verzeichnissen ablegen. + Wenn Sie GPU-Geräte verwenden möchten, stellen Sie sicher, dass Ihre Container nvidia-docker-kompatibel sind. Fügen Sie nur das CUDA-Toolkit in die Container ein. Bündeln Sie NVIDIA-Treiber nicht mit dem Abbild. Mehr Informationen über nvidia-docker finden Sie unter [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker). # So konfiguriert Amazon SageMaker Processing Eingabe und Ausgabe für Ihren Verarbeitungscontainer Wenn Sie einen Verarbeitungsauftrag mit der `CreateProcessingJob`-Operation erstellen, können Sie mehrere – `ProcessingInput`und `ProcessingOutput`-Werte angeben. Mit dem `ProcessingInput`-Parameter geben Sie eine Amazon Simple Storage Service (Amazon S3)-URI an, von der Daten heruntergeladen werden sollen, sowie einen Pfad in Ihrem Verarbeitungscontainer, in den die Daten heruntergeladen werden sollen. Der `ProcessingOutput`-Parameter konfiguriert einen Pfad in Ihrem Verarbeitungscontainer, von dem aus Daten hochgeladen werden sollen, sowie den Ort in Amazon S3, an den diese Daten hochgeladen werden sollen. Der Pfad im Verarbeitungscontainer muss für `ProcessingInput` und `ProcessingOutput` mit `/opt/ml/processing/ ` beginnen. Beispielsweise können Sie einen Verarbeitungsauftrag mit einem `ProcessingInput`-Parameter erstellen, der Daten aus `s3://your-data-bucket/path/to/input/csv/data` in den Pfad `/opt/ml/processing/csv` im Verarbeitungscontainer herunterlädt, und einem `ProcessingOutput`-Parameter, der Daten von `/opt/ml/processing/processed_csv` in `s3://your-data-bucket/path/to/output/csv/data` hochlädt. Die Eingabedaten würden dann vom Verarbeitungsauftrag gelesen und die Ausgabedaten in `/opt/ml/processing/processed_csv` geschrieben. Anschließend werden die in diesen Pfad geschriebenen Daten an den angegebenen Amazon S3-Ausgabeort hochgeladen. **Wichtig** Symbolische Links (Symlinks) können nicht verwendet werden, um Ausgabedaten auf Amazon S3 hochzuladen. Symlinks werden beim Hochladen von Ausgabedaten nicht befolgt. # So stellt Amazon SageMaker Processing Protokolle und Metriken für Ihren Verarbeitungscontainer bereit Wenn Ihr Verarbeitungscontainer in `stdout` oder schreibt`stderr`, speichert Amazon SageMaker Processing die Ausgabe jedes Verarbeitungscontainers und stellt sie in CloudWatch Amazon-Protokollen ab. Weitere Informationen zur Protokollierung finden Sie unter [CloudWatch Protokolle für Amazon SageMaker AI](logging-cloudwatch.md). Amazon SageMaker Processing bietet auch CloudWatch Metriken für jede Instance, auf der Ihr Verarbeitungscontainer ausgeführt wird. Weitere Informationen zu Metriken finden Sie unter [SageMaker Amazon-KI-Metriken bei Amazon CloudWatch](monitoring-cloudwatch.md). ## So konfiguriert Amazon SageMaker Processing Ihren Verarbeitungscontainer Amazon SageMaker Processing stellt Konfigurationsinformationen für Ihren Verarbeitungscontainer über Umgebungsvariablen und zwei JSON-Dateien — `/opt/ml/config/processingjobconfig.json` und `/opt/ml/config/resourceconfig.json` — an vordefinierten Stellen im Container bereit. Beim Start eines Verarbeitungsauftrags werden die Umgebungsvariablen verwendet, die Sie mit der `Environment`-Zuordnung in der `CreateProcessingJob`-Anforderung angegeben haben. Die `/opt/ml/config/processingjobconfig.json`-Datei enthält Informationen über die Hostnamen Ihrer Verarbeitungscontainer und sie wird auch in der `CreateProcessingJob`-Anforderung angegeben. Das folgende Beispiel zeigt das Format der `/opt/ml/config/processingjobconfig.json`-Datei. ``` { "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 } } ``` Die `/opt/ml/config/resourceconfig.json`-Datei enthält Informationen zu den Hostnamen Ihrer Verarbeitungscontainer. Verwenden Sie diese Hostnamen, wenn Sie verteilten Verarbeitungscode erstellen oder ausführen. ``` { "current_host": "algo-1", "hosts": ["algo-1","algo-2","algo-3"] } ``` Verwenden Sie nicht die in `/etc/hostname` oder `/etc/hosts` enthaltenen Informationen zu den Hostnamen, da diese ungenau sind. Hostnamen-Informationen sind möglicherweise nicht sofort für den Verarbeitungscontainer verfügbar. Wir empfehlen, eine Wiederholungsrichtlinie für Operationen zur Auflösung des Hostnamens hinzuzufügen, sobald Knoten im Cluster verfügbar werden. # Speichern und Zugriff auf Metadateninformationen zu Ihrem Verarbeitungsauftrag Container können UTF-8-codierten Text in die `/opt/ml/output/message`-Datei schreiben, um Metadaten aus dem Verarbeitungscontainer zu speichern, nachdem dieser geschlossen wurde. Nachdem der Verarbeitungsauftrag in einen Terminalstatus („`Completed`“, „`Stopped`“ oder „`Failed`“) übergangen ist, enthält das Feld „`ExitMessage`“ in [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html) die ersten 1 KB dieser Datei. Greifen Sie auf den ursprünglichen Teil der Datei mit einem Aufruf an [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html) zu. Dieser wird dann über den `ExitMessage`-Parameter zurückgegeben. Beispiel: Bei fehlgeschlagenen Verarbeitungsaufträgen können Sie dieses Feld verwenden, um Informationen zu erhalten, warum der Verarbeitungscontainer fehlgeschlagen ist. **Wichtig** Schreiben Sie keine sensiblen Daten in die `/opt/ml/output/message`-Datei. Wenn die Daten in dieser Datei nicht UTF-8-codiert sind, schlägt der Auftrag fehl und gibt `ClientError` zurück. Werden mehrere Container mit `ExitMessage,` beendet, dann werden die Inhalte von `ExitMessage` aus jedem einzelnen Verarbeitungscontainer miteinander verkettet und dann auf 1 KB gekürzt. # Führen Sie Ihren Verarbeitungscontainer mit dem SageMaker AI Python SDK aus Sie können das SageMaker Python-SDK verwenden, um Ihr eigenes Verarbeitungsbild mithilfe der `Processor` Klasse auszuführen. Das folgende Beispiel zeigt, wie Sie Ihren eigenen Verarbeitungscontainer mit einer Eingabe von Amazon Simple Storage Service (Amazon S3) und einer Ausgabe an Amazon S3 ausführen. ``` 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='')], ) ``` Anstatt den Verarbeitungscode in das Verarbeitungs-Image zu integrieren, können Sie einen `ScriptProcessor` mit Ihrem eigenen Image und dem auszuführenden Befehl bereitstellen. Geben Sie diese zusammen mit dem Code an, den Sie in diesem Container ausführen möchten. Ein Beispiel finden Sie unter [Ausführen von Scripts mit Ihrem eigenen Verarbeitungscontainer](processing-container-run-scripts.md). Sie können auch das Scikit-Learn-Image verwenden, das Amazon SageMaker Processing zur Verfügung stellt, `SKLearnProcessor` um Scikit-Learn-Skripts auszuführen. Ein Beispiel finden Sie unter [Ausführen eines Verarbeitungsjobs mit scikit-learn](use-scikit-learn-processing-container.md).