

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejecución por lotes de trabajos de inferencia
<a name="autopilot-deploy-models-batch"></a>

La inferencia por lotes, también conocida como inferencia fuera de línea, genera predicciones de modelos a partir de un lote de observaciones. La inferencia por lotes es una buena opción para conjuntos de datos grandes o si no necesita una respuesta inmediata a una solicitud de predicción del modelo. Por el contrario, la inferencia en línea ([inferencia en tiempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-deploy-models.html#autopilot-deploy-models-realtime)) genera predicciones en tiempo real. Puede realizar inferencias por lotes a partir de un modelo de piloto automático mediante el [SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/), la interfaz de usuario (UI) del piloto automático, el SDK [AWS para Python (boto3) o ()](https://aws.amazon.com/sdk-for-python/). AWS Command Line Interface [AWS CLI](https://docs.aws.amazon.com/cli/)

En las siguientes pestañas se muestran tres opciones para implementar el modelo: usar APIs la interfaz de usuario de Autopilot o implementarlo desde diferentes cuentas. APIs En estas instrucciones, se da por sentado que ya ha creado un modelo con Piloto automático. Si no dispone de un modelo, consulte [Creación de trabajos de regresión o clasificación para datos tabulares mediante la API de AutoML](autopilot-automate-model-development-create-experiment.md). Para ver ejemplos de cada opción, abra cada pestaña.

## Implementar un modelo con la interfaz de usuario de Piloto automático
<a name="autopilot-deploy-models-batch-ui"></a>

La interfaz de usuario de Piloto automático contiene útiles menús desplegables, botones, información sobre herramientas, etc. que le guiarán por la implementación del modelo.

Los siguientes pasos muestran cómo implementar un modelo de un experimento de Piloto automático para predicciones por lotes. 

1. Inicia sesión en [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)y selecciona **Studio** en el panel de navegación.

1. En el panel de navegación izquierdo, seleccione **Studio**.

1. En **Introducción**, seleccione el dominio en el que quiera iniciar la aplicación de Studio. Si su perfil de usuario solo pertenece a un dominio, no verá la opción para seleccionar un dominio.

1. Seleccione el perfil de usuario para el que desee iniciar la aplicación de Studio Classic. Si no hay ningún perfil de usuario en el dominio, seleccione **Crear perfil de usuario**. Para obtener más información, consulte [Adición de perfiles de usuario](https://docs.aws.amazon.com/sagemaker/latest/dg/domain-user-profile-add.html).

1. Seleccione **Lanzar Studio**. Si el perfil de usuario pertenece a un espacio compartido, elija **Abrir espacios**. 

1. Cuando se abra la consola de SageMaker Studio Classic, pulse el botón **Iniciar SageMaker Studio**.

1. Seleccione **AutoML** en el panel de navegación izquierdo.

1. En **Nombre**, seleccione el experimento de Piloto automático correspondiente al modelo que desee implementar. Se abrirá una nueva pestaña **TRABAJO DE PILOTO AUTOMÁTICO**.

1. En la sección **Nombre del modelo**, seleccione el modelo que desee eliminar.

1. Elija **Deploy model (Implementar modelo)**. Se abrirá una nueva pestaña.

1. Seleccione **Hacer predicciones por lotes** en la parte superior de la página.

1. En **Configuración del trabajo de transformación por lotes**, introduzca el **Tipo de instancia**, el **Recuento de instancias** y otros datos opcionales.

1. En la sección **Configuración de datos de entrada**, abra el menú desplegable. 

   1. Para el **tipo de datos S3**, elija **ManifestFile**o **S3Prefix**.

   1. **Para el **tipo Split**, elija **Line**, **Recordio **TFRecord****o Ninguno.**

   1. En **Compresión**, elija **Gzip** o **Ninguno**. 

1. En **Ubicación de S3**, introduzca la ubicación del bucket de Amazon S3 de los datos de entrada y otros datos opcionales.

1. En **Configuración de datos de salida**, introduzca el bucket de S3 para los datos de salida y elija cómo [ensamblar la salida](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#sagemaker-Type-TransformOutput-AssembleWith) de su trabajo. 

   1. En **Configuración adicional (opcional)**, puede introducir un tipo de MIME y una **Clave de cifrado de S3**.

1. Para el **filtrado de entrada/salida y las uniones de datos (opcional)**, introduzca una JSONpath expresión para filtrar los datos de entrada, unir los datos de origen de entrada con los datos de salida e introducir una JSONpath expresión para filtrar los datos de salida. 

   1. [Para ver ejemplos de cada tipo de filtro, consulta la API. DataProcessing ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html#sagemaker-Type-DataProcessing-InputFilter)

1. Para realizar predicciones por lotes en su conjunto de datos de entrada, seleccione **Crear trabajo de transformación por lotes**. Aparecerá una nueva pestaña **Trabajos de transformación por lotes**.

1. En la pestaña **Trabajos de transformación por lotes**, busque el nombre de su trabajo en la sección **Estado**. A continuación, compruebe el progreso del trabajo. 

## Implemente mediante SageMaker APIs
<a name="autopilot-deploy-models-batch-steps"></a>

Para utilizarla SageMaker APIs para la inferencia por lotes, hay tres pasos:

1. **Obtener las definiciones de candidatos** 

   Las definiciones candidatas de se [InferenceContainers](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLCandidate.html#sagemaker-Type-AutoMLCandidate-InferenceContainers)utilizan para crear un modelo de SageMaker IA. 

   El siguiente ejemplo muestra cómo utilizar la [DescribeAutoMLJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeAutoMLJob.html)API para obtener definiciones de candidatos para el mejor modelo candidato. Consulte el siguiente AWS CLI comando como ejemplo.

   ```
   aws sagemaker describe-auto-ml-job --auto-ml-job-name {{<job-name>}} --region {{<region>}}
   ```

   Usa la [ListCandidatesForAutoMLJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListCandidatesForAutoMLJob.html)API para enumerar todos los candidatos. Observe el siguiente comando AWS CLI como ejemplo.

   ```
   aws sagemaker list-candidates-for-auto-ml-job --auto-ml-job-name {{<job-name>}} --region {{<region>}}
   ```

1. **Cree un modelo de SageMaker IA**

   Para crear un modelo de SageMaker IA mediante la [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API, utilice las definiciones de contenedor de los pasos anteriores. Observe el siguiente comando AWS CLI como ejemplo.

   ```
   aws sagemaker create-model --model-name '{{<your-custom-model-name>}}' \
                       --containers ['{{<container-definition1}}>, {{<container-definition2>}}, {{<container-definition3>}}]' \
                       --execution-role-arn '{{<execution-role-arn>}}' --region '{{<region>}}
   ```

1. **Cree un trabajo de transformación de SageMaker IA** 

   En el siguiente ejemplo, se crea un trabajo de transformación de la SageMaker IA con la [CreateTransformJob](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-transform-job.html)API. Consulte el siguiente AWS CLI comando como ejemplo.

   ```
   aws sagemaker create-transform-job --transform-job-name '{{<your-custom-transform-job-name>}}' --model-name '{{<your-custom-model-name-from-last-step>}}'\
   --transform-input '{
           "DataSource": {
               "S3DataSource": {
                   "S3DataType": "S3Prefix", 
                   "S3Uri": "{{<your-input-data>}}" 
               }
           },
           "ContentType": "{{text/csv}}",
           "SplitType": "Line"
       }'\
   --transform-output '{
           "S3OutputPath": "{{<your-output-path>}}",
           "AssembleWith": "Line" 
       }'\
   --transform-resources '{
           "InstanceType": "{{<instance-type>}}", 
           "InstanceCount": {{1}}
       }' --region '{{<region>}}'
   ```

Comprueba el progreso de tu trabajo de transformación mediante la [DescribeTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTransformJob.html)API. Consulte el siguiente AWS CLI comando como ejemplo.

```
aws sagemaker describe-transform-job --transform-job-name '{{<your-custom-transform-job-name>}}' --region {{<region>}}
```

Una vez finalizado el trabajo, el resultado previsto estará disponible en `<your-output-path>`. 

El nombre de archivo de salida tiene el siguiente formato: `<input_data_file_name>.out`. Por ejemplo, si el archivo de entrada es `text_x.csv`, el nombre de la salida será `text_x.csv.out`.

Las siguientes pestañas muestran ejemplos de código para el SDK de SageMaker Python, el AWS SDK para Python (boto3) y el. AWS CLI

------
#### [ SageMaker Python SDK ]

En el siguiente ejemplo, se utiliza el **[SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html)** para realizar predicciones por lotes.

```
from sagemaker import AutoML

sagemaker_session= sagemaker.session.Session()

job_name = '{{test-auto-ml-job}}' # your autopilot job name
automl = AutoML.attach(auto_ml_job_name=job_name)
output_path = '{{s3://test-auto-ml-job/output}}'
input_data = '{{s3://test-auto-ml-job/test_X.csv}}'

# call DescribeAutoMLJob API to get the best candidate definition
best_candidate = automl.describe_auto_ml_job()['BestCandidate']
best_candidate_name = best_candidate['CandidateName']

# create model
model = automl.create_model(name=best_candidate_name, 
               candidate=best_candidate)

# create transformer
transformer = model.transformer(instance_count={{1}}, 
    instance_type='{{ml.m5.2xlarge}}',
    assemble_with='Line',
    output_path=output_path)

# do batch transform
transformer.transform(data=input_data,
                      split_type='Line',
                       content_type='{{text/csv}}',
                       wait=True)
```

------
#### [ AWS SDK for Python (boto3) ]

 El siguiente ejemplo usa el **SDK de AWS para Python (boto3)** a fin de hacer predicciones por lotes.

```
import sagemaker 
import boto3

session = sagemaker.session.Session()

sm_client = boto3.client('sagemaker', region_name='{{us-west-2}}')
role = '{{arn:aws:iam::1234567890:role/sagemaker-execution-role}}'
output_path = '{{s3://test-auto-ml-job/output}}'
input_data = '{{s3://test-auto-ml-job/test_X.csv}}'

best_candidate = sm_client.describe_auto_ml_job(AutoMLJobName=job_name)['BestCandidate']
best_candidate_containers = best_candidate['InferenceContainers']
best_candidate_name = best_candidate['CandidateName']

# create model
reponse = sm_client.create_model(
    ModelName = best_candidate_name,
    ExecutionRoleArn = role,
    Containers = best_candidate_containers 
)

# Lauch Transform Job
response = sm_client.create_transform_job(
    TransformJobName=f'{best_candidate_name}-transform-job',
    ModelName=model_name,
    TransformInput={
        'DataSource': {
            'S3DataSource': {
                'S3DataType': 'S3Prefix',
                'S3Uri': input_data
            }
        },
        'ContentType': "{{text/csv}}",
        'SplitType': 'Line'
    },
    TransformOutput={
        'S3OutputPath': output_path,
        'AssembleWith': 'Line',
    },
    TransformResources={
        'InstanceType': '{{ml.m5.2xlarge}}',
        'InstanceCount': {{1}},
    },
)
```

El trabajo de inferencia por lotes devuelve una respuesta con el siguiente formato.

```
{'TransformJobArn': '{{arn:aws:sagemaker:us-west-2:1234567890:transform-job/test-transform-job}}',
 'ResponseMetadata': {'RequestId': '659f97fc-28c4-440b-b957-a49733f7c2f2',
  'HTTPStatusCode': 200,
  'HTTPHeaders': {'x-amzn-requestid': '659f97fc-28c4-440b-b957-a49733f7c2f2',
   'content-type': 'application/x-amz-json-1.1',
   'content-length': '96',
   'date': 'Thu, 11 Aug 2022 22:23:49 GMT'},
  'RetryAttempts': 0}}
```

------
#### [ AWS Command Line Interface (AWS CLI) ]

1. **Obtenga las definiciones de candidatos** con el siguiente ejemplo de código.

   ```
   aws sagemaker describe-auto-ml-job --auto-ml-job-name '{{test-automl-job}}' --region {{us-west-2}}
   ```

1. **Cree el modelo** con el siguiente ejemplo de código.

   ```
   aws sagemaker create-model --model-name '{{test-sagemaker-model}}'
   --containers '[{
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-sklearn-automl:2.5-1-cpu-py3",
       "ModelDataUrl": "{{s3://amzn-s3-demo-bucket/out/test-job1/data-processor-models/test-job1-dpp0-1-e569ff7ad77f4e55a7e549a/output/model.tar.gz}}",
       "Environment": {
           "AUTOML_SPARSE_ENCODE_RECORDIO_PROTOBUF": "1",
           "AUTOML_TRANSFORM_MODE": "feature-transform",
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "application/x-recordio-protobuf",
           "SAGEMAKER_PROGRAM": "sagemaker_serve",
           "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code"
       }
   }, {
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-xgboost:1.3-1-cpu-py3",
       "ModelDataUrl": "{{s3://amzn-s3-demo-bucket/out/test-job1/tuning/flicdf10v2-dpp0-xgb/test-job1E9-244-7490a1c0/output/model.tar.gz}}",
       "Environment": {
           "MAX_CONTENT_LENGTH": "20971520",
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "text/csv",
           "SAGEMAKER_INFERENCE_OUTPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_SUPPORTED": "predicted_label,probability,probabilities" 
       }
   }, {
       "Image": "348316444620.dkr.ecr.us-west-2.amazonaws.com/sagemaker-sklearn-automl:2.5-1-cpu-py3", 
       "ModelDataUrl": "{{s3://amzn-s3-demo-bucket/out/test-job1/data-processor-models/test-job1-dpp0-1-e569ff7ad77f4e55a7e549a/output/model.tar.gz}}", 
       "Environment": { 
           "AUTOML_TRANSFORM_MODE": "inverse-label-transform", 
           "SAGEMAKER_DEFAULT_INVOCATIONS_ACCEPT": "text/csv", 
           "SAGEMAKER_INFERENCE_INPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_OUTPUT": "predicted_label", 
           "SAGEMAKER_INFERENCE_SUPPORTED": "predicted_label,probability,labels,probabilities", 
           "SAGEMAKER_PROGRAM": "sagemaker_serve", 
           "SAGEMAKER_SUBMIT_DIRECTORY": "/opt/ml/model/code" 
       } 
   }]' \
   --execution-role-arn '{{arn:aws:iam::1234567890:role/sagemaker-execution-role}}' \
   --region '{{us-west-2}}'
   ```

1. **Cree el trabajo de transformación** con el siguiente ejemplo de código.

   ```
   aws sagemaker create-transform-job --transform-job-name '{{test-tranform-job}}'\
    --model-name '{{test-sagemaker-model}}'\
   --transform-input '{
           "DataSource": {
               "S3DataSource": {
                   "S3DataType": "S3Prefix",
                   "S3Uri": "{{s3://amzn-s3-demo-bucket/data.csv}}"
               }
           },
           "ContentType": "{{text/csv}}",
           "SplitType": "Line"
       }'\
   --transform-output '{
           "S3OutputPath": "{{s3://amzn-s3-demo-bucket/output/}}",
           "AssembleWith": "Line"
       }'\
   --transform-resources '{
           "InstanceType": "{{ml.m5.2xlarge}}",
           "InstanceCount": {{1}}
       }'\
   --region '{{us-west-2}}'
   ```

1. **Cree el progreso del trabajo de transformación** con el siguiente ejemplo de código. 

   ```
   aws sagemaker describe-transform-job --transform-job-name  '{{test-tranform-job}}' --region {{us-west-2}}
   ```

   Lo que sigue es la respuesta del trabajo de transformación.

   ```
   {
       "TransformJobName": "{{test-tranform-job}}",
       "TransformJobArn": "{{arn:aws:sagemaker:us-west-2:1234567890:transform-job/test-tranform-job}}",
       "TransformJobStatus": "InProgress",
       "ModelName": "{{test-model}}",
       "TransformInput": {
           "DataSource": {
               "S3DataSource": {
                   "S3DataType": "S3Prefix",
                   "S3Uri": "{{s3://amzn-s3-demo-bucket/data.csv}}"
               }
           },
           "ContentType": "{{text/csv}}",
           "CompressionType": "None",
           "SplitType": "Line"
       },
       "TransformOutput": {
           "S3OutputPath": "{{s3://amzn-s3-demo-bucket/output/}}",
           "AssembleWith": "Line",
           "KmsKeyId": ""
       },
       "TransformResources": {
           "InstanceType": "{{ml.m5.2xlarge}}",
           "InstanceCount": {{1}}
       },
       "CreationTime": 1662495635.679,
       "TransformStartTime": 1662495847.496,
       "DataProcessing": {
           "InputFilter": "$",
           "OutputFilter": "$",
           "JoinSource": "None"
       }
   }
   ```

   Después de que `TransformJobStatus` cambie a `Completed`, puede comprobar el resultado de la inferencia en `S3OutputPath`.

------

## Implementar modelos desde diferentes cuentas
<a name="autopilot-deploy-models-batch-across-accounts"></a>

Para crear un trabajo de inferencia por lotes en una cuenta diferente a la cuenta en la que se generó el modelo, siga las instrucciones en [Implementar modelos desde diferentes cuentas](autopilot-deploy-models-realtime.md#autopilot-deploy-models-realtime-across-accounts). A continuación, puede crear modelos y transformar trabajos siguiendo los [Implemente mediante SageMaker APIs](#autopilot-deploy-models-batch-steps).