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.
# Implementación y predicción en modelos de Piloto automático
Esta guía de Amazon SageMaker Autopilot incluye los pasos para la implementación de modelos, la configuración de la inferencia en tiempo real y la ejecución de la inferencia con trabajos por lotes.
Después de entrenar los modelos en Piloto automático, puede implementarlos para obtener predicciones de una de las dos formas siguientes:
1. Utilice [Implementación de modelos para inferencia en tiempo real](autopilot-deploy-models-realtime.md) para configurar un punto de conexión y obtener predicciones de forma interactiva. La inferencia en tiempo real es idónea para cargas de trabajo de inferencia con requisitos en tiempo real, interactivos y de baja latencia.
1. Utilice [Ejecución por lotes de trabajos de inferencia](autopilot-deploy-models-batch.md) para hacer predicciones en paralelo en lotes de observaciones de un conjunto de datos completo. 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.
**nota**
Para evitar incurrir en cargos innecesarios, cuando los recursos y puntos de conexión que ha creado a partir de la implementación del modelo ya no sean necesarios, puede eliminarlos. Para obtener información sobre los precios de las instancias por región, consulta [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
# Implementación de modelos para inferencia en tiempo real
La inferencia en tiempo real es idónea para cargas de trabajo de inferencia con requisitos en tiempo real, interactivos y de baja latencia. Esta sección le muestra cómo puede usar la inferencia en tiempo real para obtener predicciones de forma interactiva a partir de su modelo.
Para implementar el modelo que produjo la mejor métrica de validación en un experimento de Piloto automático, tiene varias opciones. Por ejemplo, si utiliza el piloto automático en SageMaker Studio Classic, puede implementar el modelo de forma automática o manual. También se puede utilizar SageMaker APIs para implementar manualmente un modelo de piloto automático.
Las siguientes pestañas muestran tres opciones para implementar el modelo. 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.
## Implementación con la interfaz de usuario (IU) de Piloto automático
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. Puede realizar la implementación de forma automática o manual.
+ **Implementación automática**: para implementar automáticamente el mejor modelo de un experimento de Piloto automático en un punto de conexión
1. [Crea un experimento](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development-create-experiment.html) en SageMaker Studio Classic.
1. Cambie el valor de **Implementación automática** a **Sí**.
**nota**
**La implementación automática fallará si la cuota de recursos predeterminada o la cuota de clientes para las instancias de puntos de conexión de una región son demasiado limitadas.** En el modo de optimización de hiperparámetros (HPO), debe tener al menos dos instancias ml.m5.2xlarge. En el modo de ensamblaje, debe tener al menos una instancia ml.m5.12xlarge. Si se produce un error relacionado con las cuotas, puede [solicitar un aumento del límite de servicio](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html) para las instancias de punto final de SageMaker IA.
+ **Implementación manual**: para implementar manualmente el mejor modelo de un experimento de Piloto automático en un punto de conexión
1. [Crea un experimento](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development-create-experiment.html) en SageMaker Studio Classic.
1. Cambie el valor de **Implementación automática** a **No**.
1. En **Nombre del modelo**, seleccione el modelo que desea implementar.
1. Seleccione el botón naranja **Implementación y configuración avanzada**, situado a la derecha de la clasificación. Se abrirá una nueva pestaña.
1. Configure el nombre del punto de conexión, el tipo de instancia y otros datos opcionales.
1. Seleccione el **Modelo de implementación** naranja para implementarlo en un punto de conexión.
1. Compruebe el progreso del proceso de creación de terminales en [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)la sección de puntos finales. Esa sección se encuentra en el menú desplegable **Inferencia** del panel de navegación.
1. Cuando el estado del punto final cambie de **Crear** a **InService**, como se muestra a continuación, vuelva a Studio Classic e invoque el punto final.
![\[SageMaker Consola de IA: página de puntos finales para crear un punto final o comprobar el estado del punto final.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/autopilot/autopilot-check-progress.PNG)
## Implemente mediante SageMaker APIs
También puede obtener inferencias en tiempo real implementando su modelo mediante **llamadas a API**. En esta sección se muestran los cinco pasos de este proceso mediante fragmentos de código AWS Command Line Interface (AWS CLI).
Para ver ejemplos de código completos para ambos AWS CLI comandos y el AWS SDK para Python (boto3), abre las pestañas siguiendo estos pasos.
1. **Obtener las definiciones de candidatos**
Obtenga las definiciones de contenedores candidatos en. [InferenceContainers](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLCandidate.html#sagemaker-Type-AutoMLCandidate-InferenceContainers) Estas definiciones candidatas se utilizan para crear un modelo de SageMaker IA.
En el siguiente ejemplo, se utiliza 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 --region
```
1. **Enumerar los candidatos**
En el siguiente ejemplo, se utiliza 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 --region
```
1. **Cree un modelo de SageMaker IA**
Utilice las definiciones de contenedor de los pasos anteriores para crear un modelo de SageMaker IA mediante la [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API. Consulte el siguiente AWS CLI comando como ejemplo.
```
aws sagemaker create-model --model-name '' \
--containers [', , ]' \
--execution-role-arn '' --region '
```
1. **Crear la configuración de un punto de conexión**
En el siguiente ejemplo, se utiliza la [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API para crear una configuración de punto final. Consulte el siguiente AWS CLI comando como ejemplo.
```
aws sagemaker create-endpoint-config --endpoint-config-name '' \
--production-variants '' \
--region ''
```
1. **Crear el punto de conexión**
En el siguiente AWS CLI ejemplo, se utiliza la [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API para crear el punto final.
```
aws sagemaker create-endpoint --endpoint-name '' \
--endpoint-config-name '' \
--region ''
```
Compruebe el progreso de la implementación de su punto final mediante la [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API. Consulte el siguiente AWS CLI comando como ejemplo.
```
aws sagemaker describe-endpoint —endpoint-name '' —region
```
Cuando `EndpointStatus` cambie a `InService`, el punto de conexión estará listo para usarse en la inferencia en tiempo real.
1. **Invocar al punto de conexión**
La siguiente estructura de comandos invoca el punto de conexión para realizar inferencias en tiempo real.
```
aws sagemaker invoke-endpoint --endpoint-name '' \
--region '' --body '' [--content-type] ''
```
Las siguientes pestañas contienen ejemplos de código completos para implementar un modelo con el SDK de AWS para Python (boto3) o la AWS CLI.
------
#### [ AWS SDK for Python (boto3) ]
1. **Obtenga las definiciones de candidatos** con el siguiente ejemplo de código.
```
import sagemaker
import boto3
session = sagemaker.session.Session()
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
job_name = 'test-auto-ml-job'
describe_response = sm_client.describe_auto_ml_job(AutoMLJobName=job_name)
# extract the best candidate definition from DescribeAutoMLJob response
best_candidate = describe_response['BestCandidate']
# extract the InferenceContainers definition from the caandidate definition
inference_containers = best_candidate['InferenceContainers']
```
1. **Cree el modelo** con el siguiente ejemplo de código.
```
# Create Model
model_name = 'test-model'
sagemaker_role = 'arn:aws:iam:444455556666:role/sagemaker-execution-role'
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
Containers = inference_containers
)
```
1. **Cree la configuración de punto de conexión** con el siguiente ejemplo de código.
```
endpoint_config_name = 'test-endpoint-config'
instance_type = 'ml.m5.2xlarge'
# for all supported instance types, see
# https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html#sagemaker-Type-ProductionVariant-InstanceType # Create endpoint config
endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": "variant1",
"ModelName": model_name,
"InstanceType": instance_type,
"InitialInstanceCount": 1
}
]
)
print(f"Created EndpointConfig: {endpoint_config_response['EndpointConfigArn']}")
```
1. **Cree el punto de conexión** e implemente el modelo con el siguiente ejemplo de código.
```
# create endpoint and deploy the model
endpoint_name = 'test-endpoint'
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
print(create_endpoint_response)
```
**Compruebe el estado de la creación del punto de conexión** mediante el siguiente ejemplo de código.
```
# describe endpoint creation status
status = sagemaker_client.describe_endpoint(EndpointName=endpoint_name)["EndpointStatus"]
```
1. **Invoque el punto de conexión** para realizar inferencias en tiempo real con la siguiente estructura de comandos.
```
# once endpoint status is InService, you can invoke the endpoint for inferencing
if status == "InService":
sm_runtime = boto3.Session().client('sagemaker-runtime')
inference_result = sm_runtime.invoke_endpoint(EndpointName='test-endpoint', ContentType='text/csv', Body='1,2,3,4,class')
```
------
#### [ 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", amzn-s3-demo-bucket1
"ModelDataUrl": "s3://amzn-s3-demo-bucket/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/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", aws-region
"ModelDataUrl": "s3://amzn-s3-demo-bucket/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'
```
Para obtener más información, consulte [creación de un modelo](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sagemaker/create-model.html).
El comando `create model` devolverá una respuesta con el siguiente formato.
```
{
"ModelArn": "arn:aws:sagemaker:us-west-2:1234567890:model/test-sagemaker-model"
}
```
1. **Cree la configuración de punto de conexión** con el siguiente ejemplo de código.
```
aws sagemaker create-endpoint-config --endpoint-config-name 'test-endpoint-config' \
--production-variants '[{"VariantName": "variant1",
"ModelName": "test-sagemaker-model",
"InitialInstanceCount": 1,
"InstanceType": "ml.m5.2xlarge"
}]' \
--region us-west-2
```
El comando `create endpoint` devolverá una respuesta con el siguiente formato.
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:1234567890:endpoint-config/test-endpoint-config"
}
```
1. **Cree un punto de conexión** con el siguiente ejemplo de código.
```
aws sagemaker create-endpoint --endpoint-name 'test-endpoint' \
--endpoint-config-name 'test-endpoint-config' \
--region us-west-2
```
El comando `create endpoint` devolverá una respuesta con el siguiente formato.
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:1234567890:endpoint/test-endpoint"
}
```
Compruebe el progreso de la implementación del punto de conexión mediante el siguiente ejemplo de código [describe-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint.html) de la CLI.
```
aws sagemaker describe-endpoint --endpoint-name 'test-endpoint' --region us-west-2
```
La comprobación de progreso anterior devolverá una respuesta con el siguiente formato.
```
{
"EndpointName": "test-endpoint",
"EndpointArn": "arn:aws:sagemaker:us-west-2:1234567890:endpoint/test-endpoint",
"EndpointConfigName": "test-endpoint-config",
"EndpointStatus": "Creating",
"CreationTime": 1660251167.595,
"LastModifiedTime": 1660251167.595
}
```
Cuando `EndpointStatus` cambie a `InService`, el punto de conexión estará listo para usarse en la inferencia en tiempo real.
1. **Invoque el punto de conexión** para realizar inferencias en tiempo real con la siguiente estructura de comandos.
```
aws sagemaker-runtime invoke-endpoint --endpoint-name 'test-endpoint' \
--region 'us-west-2' \
--body '1,51,3.5,1.4,0.2' \
--content-type 'text/csv' \
'/tmp/inference_output'
```
Para ver más opciones, consulte [invocar un punto de conexión](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sagemaker-runtime/invoke-endpoint.html).
------
## Implementar modelos desde diferentes cuentas
Puede implementar un modelo de Piloto automático desde una cuenta diferente a la cuenta original en la que se generó el modelo. Para la implementación de un modelo entre cuentas, esta sección muestra cómo hacer lo siguiente: Conceder permiso para asumir el rol a la cuenta desde la que desea realizar la implementación (la cuenta generadora). Llama a `DescribeAutoMLJob` desde la cuenta de implementación para obtener información sobre el modelo. Conceder derechos de acceso a los artefactos del modelo desde la cuenta generadora.
1. **Conceder permiso a la cuenta de implementación**
Para asumir el rol en la cuenta generadora, debe concederle permiso a la cuenta de la implementación. Esto permite que la cuenta de implementación describa las tareas de Piloto automático en la cuenta generadora.
En el siguiente ejemplo, se utiliza una cuenta generadora con una entidad `sagemaker-role` de confianza. En el ejemplo se muestra cómo conceder permiso a una cuenta de implementación con el identificador 111122223333 para que asuma el rol de cuenta generadora.
```
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"sagemaker.amazonaws.com"
],
"AWS": [ "111122223333"]
},
"Action": "sts:AssumeRole"
}
```
La nueva cuenta con el identificador 111122223333 ahora puede asumir el rol de cuenta generadora.
A continuación, llame a la API `DescribeAutoMLJob` desde la cuenta de implementación para obtener una descripción del trabajo creado por la cuenta generadora.
En el siguiente ejemplo de código, se describe el modelo de la cuenta de implementación.
```
import sagemaker
import boto3
session = sagemaker.session.Session()
sts_client = boto3.client('sts')
sts_client.assume_role
role = 'arn:aws:iam::111122223333:role/sagemaker-role'
role_session_name = "role-session-name"
_assumed_role = sts_client.assume_role(RoleArn=role, RoleSessionName=role_session_name)
credentials = _assumed_role["Credentials"]
access_key = credentials["AccessKeyId"]
secret_key = credentials["SecretAccessKey"]
session_token = credentials["SessionToken"]
session = boto3.session.Session()
sm_client = session.client('sagemaker', region_name='us-west-2',
aws_access_key_id=access_key,
aws_secret_access_key=secret_key,
aws_session_token=session_token)
# now you can call describe automl job created in account A
job_name = "test-job"
response= sm_client.describe_auto_ml_job(AutoMLJobName=job_name)
```
1. **Otorgar permiso para que la cuenta de implementación** pueda acceder a los artefactos del modelo en la cuenta generadora.
La cuenta de implementación solo necesita acceso a los artefactos del modelo en la cuenta generadora para la implementación. Se encuentran en el [S3 OutputPath](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLOutputDataConfig.html#sagemaker-Type-AutoMLOutputDataConfig-S3OutputPath) que se especificó en la llamada a la `CreateAutoMLJob` API original durante la generación del modelo.
Para que la cuenta de implementación tenga acceso a los artefactos del modelo, elija una de las siguientes opciones:
1. [Darle acceso](https://aws.amazon.com/premiumsupport/knowledge-center/cross-account-access-s3/) a la `ModelDataUrl` desde la cuenta generadora a la cuenta de implementación.
Luego, otórguele a la cuenta de implementación el permiso necesario para que asuma el rol. Siga los [pasos de inferencia en tiempo real](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-deploy-models.html#autopilot-deploy-models-realtime) para la implementación.
1. [Copie los artefactos del modelo](https://aws.amazon.com/premiumsupport/knowledge-center/copy-s3-objects-account/) del [S3](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLOutputDataConfig.html#sagemaker-Type-AutoMLOutputDataConfig-S3OutputPath) original de la cuenta generadora OutputPath a la cuenta generadora.
Para permitir el acceso a los artefactos del modelo, debe definir un modelo `best_candidate` y reasignar los contenedores del modelo a la nueva cuenta.
El siguiente ejemplo muestra cómo definir un modelo `best_candidate` y reasignar la `ModelDataUrl`.
```
best_candidate = automl.describe_auto_ml_job()['BestCandidate']
# reassigning ModelDataUrl for best_candidate containers below
new_model_locations = ['new-container-1-ModelDataUrl', 'new-container-2-ModelDataUrl', 'new-container-3-ModelDataUrl']
new_model_locations_index = 0
for container in best_candidate['InferenceContainers']:
container['ModelDataUrl'] = new_model_locations[new_model_locations_index++]
```
Tras esta asignación de contenedores, siga los pasos de [Implemente mediante SageMaker APIs](#autopilot-deploy-models-api) para la implementación.
A fin de crear una carga mediante inferencias en tiempo real, consulte el cuaderno de ejemplo para [definir una carga de prueba](https://aws.amazon.com/getting-started/hands-on/machine-learning-tutorial-automatically-create-models). Para crear la carga a partir de un archivo CSV e invocar un punto de conexión, consulte la sección **Haga predicciones con su modelo** en [Cree un modelo de machine learning de inmediato](https://aws.amazon.com/getting-started/hands-on/create-machine-learning-model-automatically-sagemaker-autopilot/#autopilot-cr-room).
# Ejecución por lotes de trabajos de inferencia
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
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
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 --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 --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 '' \
--containers [', , ]' \
--execution-role-arn '' --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 '' --model-name ''\
--transform-input '{
"DataSource": {
"S3DataSource": {
"S3DataType": "S3Prefix",
"S3Uri": ""
}
},
"ContentType": "text/csv",
"SplitType": "Line"
}'\
--transform-output '{
"S3OutputPath": "",
"AssembleWith": "Line"
}'\
--transform-resources '{
"InstanceType": "",
"InstanceCount": 1
}' --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 '' --region
```
Una vez finalizado el trabajo, el resultado previsto estará disponible en ``.
El nombre de archivo de salida tiene el siguiente formato: `.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
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).