

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Processamento de dados com processadores de framework
<a name="processing-job-frameworks"></a>

A `FrameworkProcessor` pode executar trabalhos de processamento com uma estrutura de aprendizado de máquina especificada, fornecendo a você um contêiner SageMaker gerenciado pela Amazon AI para qualquer estrutura de aprendizado de máquina que você escolher. `FrameworkProcessor`fornece contêineres pré-fabricados para as seguintes estruturas de aprendizado de máquina: Hugging Face,,, MXNet e. PyTorch TensorFlow XGBoost

A classe de `FrameworkProcessor` também fornece personalização na configuração do contêiner. A classe de `FrameworkProcessor` classe é compatível com a especificação de um diretório `source_dir` de origem para seus scripts de processamento e dependências. Com esse recurso, você pode dar ao processador acesso a vários scripts em um diretório em vez de especificar apenas um script. O `FrameworkProcessor` também é compatível com a inclusão de um arquivo `requirements.txt` no `source_dir` para personalizar as bibliotecas Python para instalação no contêiner.

Para obter mais informações sobre a `FrameworkProcessor` classe e seus métodos e parâmetros, consulte [FrameworkProcessor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html#sagemaker.processing.FrameworkProcessor)o *Amazon SageMaker AI Python* SDK.

Para ver exemplos de uso de um `FrameworkProcessor` para cada um dos frameworks de machine learning compatíveis, consulte os tópicos a seguir.

**Topics**
+ [Exemplo de código usando HuggingFaceProcessor o Amazon SageMaker Python SDK](processing-job-frameworks-hugging-face.md)
+ [MXNet Processador de estrutura](processing-job-frameworks-mxnet.md)
+ [PyTorch Processador de estrutura](processing-job-frameworks-pytorch.md)
+ [TensorFlow Processador de estrutura](processing-job-frameworks-tensorflow.md)
+ [XGBoost Processador de estrutura](processing-job-frameworks-xgboost.md)

# Exemplo de código usando HuggingFaceProcessor o Amazon SageMaker Python SDK
<a name="processing-job-frameworks-hugging-face"></a>

Hugging Face é um provedor de código aberto de modelos de processamento de linguagem natural (PLN). O `HuggingFaceProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts do Hugging Face. Ao usar o `HuggingFaceProcessor`, você pode aproveitar um contêiner do Docker integrado na Amazon com um ambiente gerenciado pelo Hugging Face para não precisar trazer seu próprio contêiner.

O exemplo de código a seguir mostra como você pode usar o `HuggingFaceProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você.

```
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 você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. *Para saber mais sobre a `HuggingFaceProcessor` aula, consulte [Hugging Face Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/sagemaker.huggingface.html) no Amazon AI Python SDK. SageMaker *

# MXNet Processador de estrutura
<a name="processing-job-frameworks-mxnet"></a>

O Apache MXNet é uma estrutura de aprendizado profundo de código aberto comumente usada para treinar e implantar redes neurais. O `MXNetProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts. MXNet Ao usar o`MXNetProcessor`, você pode aproveitar um contêiner Docker criado pela Amazon com um MXNet ambiente gerenciado para não precisar trazer seu próprio contêiner.

O exemplo de código a seguir mostra como você pode usar o `MXNetProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você.

```
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 você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. Para saber mais sobre a `MXNetProcessor` classe, consulte [MXNet Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/sagemaker.mxnet.html#mxnet-estimator) no SDK do Amazon *Python SageMaker *.

# PyTorch Processador de estrutura
<a name="processing-job-frameworks-pytorch"></a>

PyTorch é uma estrutura de aprendizado de máquina de código aberto. O `PyTorchProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts. PyTorch Ao usar o`PyTorchProcessor`, você pode aproveitar um contêiner Docker criado pela Amazon com um PyTorch ambiente gerenciado para não precisar trazer seu próprio contêiner.

O exemplo de código a seguir mostra como você pode usar o `PyTorchProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você.

Para as PyTorch versões suportadas pela SageMaker IA, consulte as [imagens disponíveis do 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 você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. Para saber mais sobre a `PyTorchProcessor` classe, consulte [PyTorch Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html) no SDK do Amazon *Python SageMaker *.

# TensorFlow Processador de estrutura
<a name="processing-job-frameworks-tensorflow"></a>

TensorFlow é uma biblioteca de aprendizado de máquina e inteligência artificial de código aberto. O `TensorFlowProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts. TensorFlow Ao usar o`TensorFlowProcessor`, você pode aproveitar um contêiner Docker criado pela Amazon com um TensorFlow ambiente gerenciado para não precisar trazer seu próprio contêiner.

O exemplo de código a seguir mostra como você pode usar o `TensorFlowProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você.

```
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 você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. Para saber mais sobre a `TensorFlowProcessor` classe, consulte [TensorFlow Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) no SDK do Amazon *Python SageMaker *.

# XGBoost Processador de estrutura
<a name="processing-job-frameworks-xgboost"></a>

XGBoost é uma estrutura de aprendizado de máquina de código aberto. O `XGBoostProcessor` SDK do Amazon SageMaker Python oferece a capacidade de executar trabalhos de processamento com scripts. XGBoost Ao usar o XGBoost processador, você pode aproveitar um contêiner Docker criado pela Amazon com um XGBoost ambiente gerenciado para não precisar trazer seu próprio contêiner.

O exemplo de código a seguir mostra como você pode usar o `XGBoostProcessor` para executar sua tarefa de processamento usando uma imagem do Docker fornecida e mantida pela SageMaker IA. Observe que, ao executar o trabalho, você pode especificar um diretório contendo seus scripts e dependências no `source_dir` argumento e pode ter um `requirements.txt` arquivo localizado dentro do seu `source_dir` diretório que especifica as dependências dos seus scripts de processamento. SageMaker O processamento instala as dependências `requirements.txt` no contêiner para você.

```
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 você tiver um arquivo `requirements.txt`, ele deverá ser uma lista das bibliotecas que você deseja instalar no contêiner. O caminho para `source_dir` pode ser um caminho de URI relativo, absoluto ou do Amazon S3. No entanto, se você usar um URI do Amazon S3, ele deverá apontar para um arquivo tar.gz. Você pode ter vários scripts no diretório que você especificar para `source_dir`. Para saber mais sobre a `XGBoostProcessor` classe, consulte [XGBoost Estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/xgboost/xgboost.html) no SDK do Amazon *Python SageMaker *.