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.
# SageMaker flujos de trabajo de IA
A medida que escala sus operaciones de aprendizaje automático (ML), puede utilizar los servicios de flujo de trabajo totalmente gestionados de Amazon SageMaker AI para implementar prácticas de integración e implementación continuas (CI/CD) para su ciclo de vida de aprendizaje automático. Con el SDK de Canalizaciones, puede elegir e integrar los pasos de la canalización en una solución unificada que automatiza el proceso de creación de modelos, desde la preparación de los datos hasta la implementación del modelo. En el caso de las arquitecturas basadas en Kubernetes, puede instalar operadores de IA en su clúster de Kubernetes para crear SageMaker trabajos de SageMaker IA de forma nativa mediante la API de Kubernetes y las herramientas de Kubernetes de línea de comandos, como `kubectl` Con los componentes de IA para las canalizaciones de Kubeflow, puedes crear y supervisar trabajos de SageMaker IA nativos desde tus canalizaciones de Kubeflow. SageMaker Se puede acceder a los parámetros del trabajo, el estado y los resultados de la SageMaker IA desde la interfaz de usuario de Kubeflow Pipelines. Por último, si desea programar trabajos por lotes, puede utilizar la integración de colas de trabajos o el servicio de flujos de AWS Batch trabajo de Jupyter basado en cuadernos para iniciar ejecuciones independientes o regulares según el cronograma que usted defina.
En resumen, AI ofrece las siguientes tecnologías de flujo de trabajo SageMaker :
+ [Canalizaciones](pipelines.md): herramienta para crear y administrar canalizaciones de ML.
+ [Orquestación de Kubernetes](kubernetes-workflows.md): Operadores de SageMaker IA personalizados para su clúster de Kubernetes y componentes para Kubeflow Pipelines.
+ [SageMaker Trabajos de cuaderno](notebook-auto-run.md): ejecuciones por lotes no interactivas bajo demanda o programadas de su cuaderno de Jupyter.
También puedes aprovechar otros servicios que se integran con SageMaker la IA para desarrollar tu flujo de trabajo. Las opciones incluyen los siguientes servicios:
+ [Flujos de trabajo de flujo](https://sagemaker.readthedocs.io/en/stable/workflows/airflow/index.html) de aire: SageMaker APIs para exportar configuraciones para crear y gestionar flujos de trabajo de flujo de aire.
+ [AWS Step Functions](https://sagemaker.readthedocs.io/en/stable/workflows/step_functions/index.html): Flujos de trabajo de aprendizaje automático de varios pasos en Python que organizan la infraestructura de SageMaker IA sin tener que aprovisionar los recursos por separado.
+ [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/getting-started-sagemaker.html): Envíe los trabajos de formación en SageMaker IA a una lista de AWS Batch trabajos, donde podrá priorizar y programar los trabajos para que se ejecuten en un entorno informático.
Para obtener más información sobre la gestión de la SageMaker formación y la inferencia, consulte [Flujos de trabajo del SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable/workflows/index.html).
**Topics**
+ [Canalizaciones](pipelines.md)
+ [Orquestación de Kubernetes](kubernetes-workflows.md)
+ [SageMaker Trabajos de cuaderno](notebook-auto-run.md)
+ [Programación de sus flujos de trabajo de ML](workflow-scheduling.md)
+ [AWS Batch soporte para trabajos de formación en SageMaker IA](training-job-queues.md)
# Canalizaciones
Amazon SageMaker Pipelines es un servicio de organización de flujos de trabajo diseñado específicamente para automatizar el desarrollo del aprendizaje automático (ML).
Las canalizaciones ofrecen las siguientes ventajas en comparación con otras ofertas de flujo de trabajo: AWS
**Infraestructura sin servidor con escalado automático** No es necesario gestionar la infraestructura de orquestación subyacente para ejecutar Pipelines, lo que le permite centrarse en las tareas principales del aprendizaje automático. SageMaker La IA aprovisiona, escala y cierra automáticamente los recursos informáticos de orquestación de procesos según lo requiera su carga de trabajo de aprendizaje automático.
**Experiencia de usuario intuitiva** Los pipelines se pueden crear y gestionar a través de la interfaz que prefieras: editor visual APIs, SDK o JSON. Puedes seguir drag-and-drop los distintos pasos de ML para crear tus canalizaciones en la interfaz visual de Amazon SageMaker Studio. En la siguiente captura de pantalla, se muestra el editor visual de Studio para las canalizaciones.
![\[Captura de pantalla de la drag-and-drop interfaz visual de Pipelines en Studio.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png)
Si prefieres gestionar tus flujos de trabajo de aprendizaje automático mediante programación, el SDK de SageMaker Python ofrece funciones de orquestación avanzadas. Para obtener más información, consulte [Amazon SageMaker Pipelines](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html) en la documentación del SDK de SageMaker Python.
**AWS Las integraciones** Pipelines proporcionan una integración perfecta con todas las funciones de SageMaker IA y otros AWS servicios para automatizar el procesamiento de datos, el entrenamiento de modelos, el ajuste, la evaluación, el despliegue y la supervisión de las tareas. Puedes incorporar las funciones de SageMaker IA en tus canalizaciones y navegar por ellas mediante enlaces profundos para crear, supervisar y depurar tus flujos de trabajo de aprendizaje automático a escala.
**Costes reducidos** Con Pipelines, solo paga por el entorno de SageMaker Studio y los trabajos subyacentes organizados por Pipelines (por ejemplo, SageMaker formación, SageMaker procesamiento, inferencia de SageMaker inteligencia artificial y almacenamiento de datos en Amazon S3).
**Auditabilidad y seguimiento del linaje** Con Canalizaciones, puede realizar un seguimiento del historial de actualizaciones y ejecuciones de las canalizaciones mediante el control de versiones integrado. Amazon SageMaker ML Lineage Tracking le ayuda a analizar las fuentes de datos y los consumidores de datos en el ciclo de vida del desarrollo del aprendizaje end-to-end automático.
**Topics**
+ [Información general de canalizaciones](pipelines-overview.md)
+ [Acciones de canalizaciones](pipelines-build.md)
# Información general de canalizaciones
Una canalización de Amazon SageMaker AI es una serie de pasos interconectados en un gráfico acíclico dirigido (DAG) que se definen mediante la drag-and-drop interfaz de usuario o el SDK de [Pipelines](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html). También puede crear una canalización utilizando el [esquema JSON de definición de canalizaciones](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/). Esta definición de JSON de DAG proporciona información sobre los requisitos y las relaciones entre cada paso de la canalización. La estructura del DAG de una canalización viene determinada por las dependencias de datos entre los pasos. Estas dependencias de datos se crean cuando las propiedades de la salida de un paso se transfieren como entrada a otro paso. En la siguiente imagen, se muestra un ejemplo de DAG de canalización:
![\[\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/pipeline-full.png)
**El DAG de ejemplo incluye los siguientes pasos:**
1. `AbaloneProcess`, una instancia del paso de [procesamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), ejecuta un script de preprocesamiento de los datos utilizados para el entrenamiento. Por ejemplo, el script podría rellenar los valores que faltan, normalizar los datos numéricos o dividir los datos en conjuntos de datos de entrenamiento, validación y prueba.
1. `AbaloneTrain`, una instancia del paso de [entrenamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-training), configura los hiperparámetros y entrena un modelo a partir de los datos de entrada preprocesados.
1. `AbaloneEval`, otra instancia del paso de [procesamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), evalúa la exactitud del modelo. En este paso, se muestra un ejemplo de una dependencia de datos: en este paso se utiliza la salida del conjunto de datos de prueba de `AbaloneProcess`.
1. `AbaloneMSECond`es un ejemplo de un paso de [condición](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-condition) que, en este ejemplo, comprueba que el mean-square-error resultado de la evaluación del modelo esté por debajo de un límite determinado. Si el modelo no cumple los criterios, la ejecución de la canalización se detiene.
1. La ejecución de la canalización realiza los siguientes pasos:
1. `AbaloneRegisterModel`, donde SageMaker AI solicita un [RegisterModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-register-model)paso para registrar el modelo como un grupo de paquetes de modelos versionados en el Registro de SageMaker Modelos de Amazon.
1. `AbaloneCreateModel`, donde la SageMaker IA da un [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-create-model)paso hacia la creación del modelo como preparación para la transformación por lotes. En`AbaloneTransform`, la SageMaker IA invoca un paso de [transformación](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-transform) para generar predicciones del modelo en un conjunto de datos que especifique.
En los siguientes temas, se describen los conceptos fundamentales de Canalizaciones. Para ver un tutorial que describe la implementación de estos conceptos, consulte [Acciones de canalizaciones](pipelines-build.md).
**Topics**
+ [Estructura y ejecución de la canalización](build-and-manage-pipeline.md)
+ [Administración de acceso de IAM](build-and-manage-access.md)
+ [Configuración de la compatibilidad entre cuentas para Canalizaciones](build-and-manage-xaccount.md)
+ [Parámetros de canalizaciones](build-and-manage-parameters.md)
+ [Pasos de canalizaciones](build-and-manage-steps.md)
+ [Lift-and-shift Código Python con el decorador @step](pipelines-step-decorator.md)
+ [Transferencia de datos entre pasos](build-and-manage-propertyfile.md)
+ [Almacenamiento en caché de pasos de canalización](pipelines-caching.md)
+ [Política de reintentos para los pasos de la canalización](pipelines-retry-policy.md)
+ [Ejecución selectiva de los pasos de la canalización](pipelines-selective-ex.md)
+ [Cálculo de referencia, detección de desviaciones y ciclo de vida con Amazon SageMaker Pipelines ClarifyCheck y QualityCheck pasos](pipelines-quality-clarify-baseline-lifecycle.md)
+ [Programación de ejecuciones de canalizaciones](pipeline-eventbridge.md)
+ [Integración de Amazon SageMaker Experiments](pipelines-experiments.md)
+ [Ejecución de canalizaciones en modo local](pipelines-local-mode.md)
+ [Solución de problemas de Amazon SageMaker Pipelines](pipelines-troubleshooting.md)
# Estructura y ejecución de la canalización
**Topics**
+ [Estructura de la canalización](#build-and-manage-pipeline-structure)
+ [Ejecución de canalización mediante la configuración del paralelismo](#build-and-manage-pipeline-execution)
## Estructura de la canalización
Una instancia de Amazon SageMaker Pipelines se compone de `name``parameters`, y`steps`. Los nombres de las canalizaciones deben ser únicos en un par `(account, region)`. Todos los parámetros utilizados en las definiciones de los pasos se deben definir en la canalización. Los pasos de la canalización enumerados determinan automáticamente su orden de ejecución en función de la dependencia de los datos entre sí. El servicio de Canalizaciones resuelve las relaciones entre los pasos del DAG de dependencia de datos para crear una serie de pasos que completa la ejecución. A continuación se muestra un ejemplo de una estructura de canalización.
**aviso**
Al crear una canalización mediante el editor visual o el SDK de Python para SageMaker IA, no incluyas información confidencial en los parámetros de la canalización ni en ningún campo de definición de pasos (como las variables de entorno). Estos campos serán visibles en el futuro cuando se devuelvan en una solicitud `DescribePipeline`.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_type,
processing_instance_count,
training_instance_type,
model_approval_status,
input_data,
batch_data,
],
steps=[step_process, step_train, step_eval, step_cond],
)
```
## Ejecución de canalización mediante la configuración del paralelismo
De forma predeterminada, una canalización realiza todos los pasos que están disponibles para ejecutarse en paralelo. Puede controlar este comportamiento mediante la propiedad `ParallelismConfiguration` al crear o actualizar una canalización, así como al iniciar o reintentar la ejecución de una canalización.
Las configuraciones de paralelismo se aplican por ejecución. Por ejemplo, si se inician dos ejecuciones, cada una de ellas puede ejecutar un máximo de 50 pasos simultáneamente, lo que supone un total de 100 pasos ejecutados simultáneamente. Además, la `ParallelismConfiguration` especificada al iniciar, reintentar o actualizar una ejecución tiene prioridad sobre la configuración de paralelismo definida en la canalización.
**Example Creación de una ejecución en canalización con `ParallelismConfiguration`**
```
pipeline = Pipeline(
name="myPipeline",
steps=[step_process, step_train]
)
pipeline.create(role, parallelism_config={"MaxParallelExecutionSteps": 50})
```
# Administración de acceso de IAM
En las siguientes secciones se describen los requisitos AWS Identity and Access Management (de IAM) de Amazon SageMaker Pipelines. Para ver un ejemplo de cómo puede implementar estos permisos, consulte [Requisitos previos](define-pipeline.md#define-pipeline-prereq).
**Topics**
+ [Permisos de rol de canalización](#build-and-manage-role-permissions)
+ [Permisos de paso de canalización](#build-and-manage-step-permissions)
+ [Configuración de CORS con buckets de Amazon S3](#build-and-manage-cors-s3)
+ [Personalización de la administración del acceso para los trabajos de Canalizaciones](#build-and-manage-step-permissions-prefix)
+ [Personalización del acceso a las versiones de canalización](#build-and-manage-step-permissions-version)
+ [Políticas de control de servicios con canalizaciones](#build-and-manage-scp)
## Permisos de rol de canalización
Su canalización requiere una función de ejecución de la canalización de IAM que se transfiere a Pipelines al crear una canalización. La función de la instancia de SageMaker IA que utilices para crear la canalización debe tener una política con el `iam:PassRole` permiso que especifique la función de ejecución de la canalización. Esto se debe a que la instancia necesita permiso para transferir tu función de ejecución de canalizaciones al servicio Pipelines para que se use en la creación y ejecución de canalizaciones. Para obtener más información acerca de los roles de IAM, consulte [Roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
El rol de ejecución de la canalización requiere los siguientes permisos:
+ Puedes usar un rol único o personalizado para cualquiera de los pasos del trabajo de SageMaker IA de tu proceso (en lugar del rol de ejecución del proceso, que se usa de forma predeterminada). Asegúrate de que tu función de ejecución en proceso haya añadido una política con el `iam:PassRole` permiso que especifique cada una de estas funciones.
+ Los permisos `Create` y `Describe` para cada uno de los tipos de trabajo de la canalización.
+ Permisos de Amazon S3 para utilizar la función `JsonGet`. Puede controlar el acceso a los recursos de Amazon S3 a través de una política basada en identidades o una política basada en recursos. Se aplica una política basada en recursos al bucket de Amazon S3 y concede acceso al bucket a Canalizaciones. Una política basada en identidades permite a la canalización realizar llamadas a Amazon S3 desde su cuenta. Para obtener más información acerca de las políticas de acceso basadas en recursos, consulte [Políticas basadas en identidad y políticas basadas en recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).
```
{
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::/*",
"Effect": "Allow"
}
```
## Permisos de paso de canalización
Las canalizaciones incluyen los pasos que ejecutan las tareas de SageMaker IA. Para que los pasos de la canalización ejecuten estos trabajos, requieren un rol de IAM en la cuenta que proporcione acceso al recurso necesario. Tu proceso transfiere esta función al director del servicio de SageMaker IA. Para obtener más información acerca de los roles de IAM, consulte [Roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
De forma predeterminada, cada paso asume el rol de ejecución de la canalización. Si lo desea, puede transferir un rol diferente a cualquiera de los pasos de su canalización. Esto garantiza que el código de cada paso no pueda afectar a los recursos utilizados en otros pasos, a menos que exista una relación directa entre los dos pasos especificados en la definición de la canalización. Estos roles se asignan al definir el procesador o el estimador de su paso. Para ver ejemplos de cómo incluir estas funciones en estas definiciones, consulta la [documentación del SDK de Python para SageMaker IA](https://sagemaker.readthedocs.io/en/stable/overview.html#using-estimators).
## Configuración de CORS con buckets de Amazon S3
Para garantizar que las imágenes se importen a sus canalizaciones desde un bucket de Amazon S3 de forma predecible, debe añadirse una configuración de CORS a los buckets de Amazon S3 desde los que se importan las imágenes. En esta sección se proporcionan instrucciones sobre cómo establecer la configuración de CORS requerida en el bucket de Amazon S3. El XML `CORSConfiguration` necesario para las canalizaciones es diferente del que aparece en [Requisito de CORS para datos de imagen de entrada](sms-cors-update.md); puede utilizar la información que contiene para obtener más información sobre el requisito de CORS en los buckets de Amazon S3.
Utilice el siguiente código de configuración de CORS para los buckets de Amazon S3 que alojan las imágenes. Para ver instrucciones sobre cómo configurar CORS, consulte [Configuración del uso compartido de recursos entre orígenes (CORS)](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-cors-configuration.html) en la Guía del usuario de Amazon Simple Storage Service. Si utiliza la consola de Amazon S3 para agregar la política a su bucket, debe utilizar el formato JSON.
**JSON**
```
[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"PUT"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": [
"Access-Control-Allow-Origin"
]
}
]
```
**XML**
```
**PUTAccess-Control-Allow-Origin
```
El siguiente GIF muestra las instrucciones que se encuentran en la documentación de Amazon S3 para añadir una política de encabezados CORS mediante la consola de Amazon S3.
![\[Gif que muestra un ejemplo sobre cómo añadir una política de encabezados de CORS mediante la consola de Amazon S3.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/sms/gifs/cors-config.gif)
## Personalización de la administración del acceso para los trabajos de Canalizaciones
Puede personalizar aún más sus políticas de IAM para que los miembros seleccionados de su organización puedan ejecutar todos los pasos de la canalización o cualquiera de ellos. Por ejemplo, puede conceder permiso a determinados usuarios para crear trabajos de entrenamiento, conceder permisos a otro grupo de usuarios para crear trabajos de procesamiento y conceder permisos a todos tus usuarios permiso para ejecutar el resto de pasos. Para usar esta característica, seleccione una cadena personalizada como prefijo al nombre del trabajo. El administrador antepone el prefijo a lo permitido ARNs , mientras que el científico de datos incluye este prefijo en las instancias de canalización. Como la política de IAM para los usuarios permitidos contiene un ARN de trabajo con el prefijo especificado, los trabajos posteriores de su paso de canalización cuentan con los permisos necesarios para continuar. El prefijo de trabajo está desactivado de forma predeterminada; debe activar esta opción en su clase `Pipeline`para usarla.
Para los trabajos con el prefijo desactivado, el nombre del trabajo tiene el formato que se muestra y es una concatenación de los campos que se describen en la siguiente tabla:
`pipelines----`
| Campo | Definición |
| --- | --- |
| pipelines | Siempre se antepone una cadena estática. Esta cadena identifica el servicio de orquestación de canalizaciones como el origen del trabajo. |
| executionId | Un búfer aleatorio para la instancia en ejecución de la canalización. |
| stepNamePrefix | El nombre del paso especificado por el usuario (indicado en el argumento `name` del paso de canalización), limitado a los primeros 20 caracteres. |
| entityToken | Un token aleatorio para garantizar la idempotencia de la entidad de paso. |
| failureCount | El número actual de reintentos que han tenido lugar para completar el trabajo. |
En este caso, no se agrega ningún prefijo personalizado al nombre del trabajo y la política de IAM correspondiente debe coincidir con esta cadena.
Para los usuarios que activan el prefijo de trabajo, el nombre del trabajo subyacente adopta el siguiente formato, con el prefijo personalizado especificado como `MyBaseJobName`:
**-**-**-**
El prefijo personalizado reemplaza a la `pipelines` cadena estática para ayudarte a reducir la selección de usuarios que pueden ejecutar el trabajo de SageMaker IA como parte de una canalización.
**Restricciones de longitud del prefijo**
Los nombres de los trabajos tienen restricciones de longitud internas específicas para cada paso de la canalización. Esta restricción también limita la longitud del prefijo permitido. Los requisitos de longitud de los prefijos son los siguientes:
| Paso de canalización | Longitud del prefijo |
| --- | --- |
| `[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`, `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`, `[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`, `[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`, `[ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)`, `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)`, `[RegisterModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)` | 38 |
| `[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`, `[AutoML](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)` | 6 |
### Aplicación de prefijos de trabajo a una política de IAM
El administrador crea políticas de IAM que permiten a los usuarios de prefijos específicos crear trabajos. El siguiente ejemplo de política permite a los científicos de datos crear trabajos de entrenamiento si utilizan el prefijo `MyBaseJobName`.
```
{
"Action": "sagemaker:CreateTrainingJob",
"Effect": "Allow",
"Resource": [
"arn:aws:sagemaker:region:account-id:*/MyBaseJobName-*"
]
}
```
### Aplicación de prefijos de trabajo a las instancias de canalización
El prefijo se especifica con el argumento `*base_job_name` de la clase de instancia del trabajo.
**nota**
Debe pasar el prefijo de trabajo con el argumento `*base_job_name` a la instancia de trabajo antes de crear un paso de canalización. Esta instancia de trabajo contiene la información necesaria para que el trabajo se ejecute como un paso de una canalización. Este argumento varía en función de la instancia de trabajo utilizada. En la siguiente lista se muestra el argumento que se debe utilizar para cada tipo de paso de la canalización:
`base_job_name` para las clases `[Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html)` (`[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`), `[Processor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html)` (`[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`) y `[AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html)` (`[AutoMLStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)`)
`tuning_base_job_name` para la clase `[Tuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)` (`[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`)
`transform_base_job_name` para la clase `[Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html)` (`[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`)
`base_job_name` de `[CheckJobConfig](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#checkjobconfig)` para las clases `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)` (Quality Check) y `[ClarifyCheckstep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)` (Clarify Check)
Para la clase `[Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html)`, el argumento utilizado depende de si ejecuta `create` o `register` en su modelo antes de pasar el resultado a `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`
Si llama a `create`, el prefijo personalizado proviene del argumento `name` cuando construye su modelo (es decir, `Model(name=)`)
Si llama a `register`, el prefijo personalizado proviene del argumento `model_package_name` de su llamada a `register` (es decir, `my_model.register(model_package_name=)`)
En el siguiente ejemplo se muestra cómo especificar un prefijo para una nueva instancia de trabajo de entrenamiento.
```
# Create a job instance
xgb_train = Estimator(
image_uri=image_uri,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=model_path,
role=role,
subnets=["subnet-0ab12c34567de89f0"],
base_job_name="MyBaseJobName"
security_group_ids=["sg-1a2bbcc3bd4444e55"],
tags = [ ... ]
encrypt_inter_container_traffic=True,
)
# Attach your job instance to a pipeline step
step_train = TrainingStep(
name="TestTrainingJob",
estimator=xgb_train,
inputs={
"train": TrainingInput(...),
"validation": TrainingInput(...)
}
)
```
El prefijo del trabajo está desactivado de forma predeterminada. Para activar esta característica, utilice la opción `use_custom_job_prefix` de `PipelineDefinitionConfig`, tal como se muestra en el siguiente fragmento:
```
from sagemaker.workflow.pipeline_definition_config import PipelineDefinitionConfig
# Create a definition configuration and toggle on custom prefixing
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True);
# Create a pipeline with a custom prefix
pipeline = Pipeline(
name="MyJobPrefixedPipeline",
parameters=[...]
steps=[...]
pipeline_definition_config=definition_config
)
```
Cree y ejecute su canalización. En el siguiente ejemplo, se crea y ejecuta una canalización, y también se muestra cómo desactivar los prefijos de trabajo y volver a ejecutar la canalización.
```
pipeline.create(role_arn=sagemaker.get_execution_role())
# Optionally, call definition() to confirm your prefixed job names are in the built JSON
pipeline.definition()
pipeline.start()
# To run a pipeline without custom-prefixes, toggle off use_custom_job_prefix, update the pipeline
# via upsert() or update(), and start a new run
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=False)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Del mismo modo, puede activar la característica para las canalizaciones existentes e iniciar una nueva ejecución que utilice prefijos de trabajo.
```
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Por último, para ver su trabajo con un prefijo personalizado, llame a `list_steps` en la ejecución de la canalización.
```
steps = execution.list_steps()
prefixed_training_job_name = steps['PipelineExecutionSteps'][0]['Metadata']['TrainingJob']['Arn']
```
## Personalización del acceso a las versiones de canalización
Puede conceder acceso personalizado a versiones específicas de Amazon SageMaker Pipelines mediante la clave de `sagemaker:PipelineVersionId` condición. Por ejemplo, la política que aparece a continuación permite iniciar las ejecuciones o actualizar la versión de la canalización solo para la versión con el ID de versión 6 o superior.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowStartPipelineExecution",
"Effect": "Allow",
"Action": [
"sagemaker:StartPipelineExecution",
"sagemaker:UpdatePipelineVersion"
],
"Resource": "*",
"Condition": {
"NumericGreaterThanEquals": {
"sagemaker:PipelineVersionId": 6
}
}
}
}
```
------
Para obtener más información sobre las claves de condición compatibles, consulta [Claves de condición para Amazon SageMaker AI](https://docs.aws.amazon.com//service-authorization/latest/reference/list_amazonsagemaker.html#amazonsagemaker-policy-keys).
## Políticas de control de servicios con canalizaciones
Las políticas de control de servicios (SCPs) son un tipo de política organizacional que puede usar para administrar los permisos en su organización. SCPs ofrecen un control central sobre el número máximo de permisos disponibles para todas las cuentas de su organización. Al utilizar Pipelines en su organización, puede asegurarse de que los científicos de datos gestionen las ejecuciones de sus pipelines sin tener que interactuar con la AWS consola.
Si utiliza una VPC con su SCP que restringe el acceso a Amazon S3, debe tomar medidas para permitir que su canalización acceda a otros recursos de Amazon S3.
Para permitir que Canalizaciones acceda a Amazon S3 fuera de su VPC con la función `JsonGet`, actualice la SCP de su organización para asegurarse de que el rol que usa Canalizaciones pueda acceder a Amazon S3. Para ello, cree una excepción para los roles que utiliza el ejecutor de Canalizaciones mediante el rol de ejecución de canalizaciones a través de una etiqueta de entidad principal y una clave de condición.
**Concesión de permiso a Canalizaciones para acceder a Amazon S3 fuera de su VPC**
1. Cree una etiqueta única para su rol de ejecución de la canalización según los pasos de [Etiquetado de usuarios y roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html).
1. Conceda una excepción en su SCP utilizando la clave de condición `Aws:PrincipalTag IAM` de la etiqueta que ha creado. Para obtener más información, consulte [Creación, actualización y eliminación de políticas de control de servicios](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_create.html).
# Configuración de la compatibilidad entre cuentas para Canalizaciones
El soporte multicuenta para Amazon SageMaker Pipelines le permite colaborar en procesos de aprendizaje automático con otros equipos u organizaciones que operan en cuentas diferentes. AWS Al configurar el uso compartido de canalizaciones entre cuentas, puede conceder acceso controlado a las canalizaciones, permitir que otras cuentas vean los detalles de las canalizaciones, activar las ejecuciones y supervisar las ejecuciones. En el siguiente tema, se explica cómo configurar el uso compartido de canalizaciones entre cuentas, las diferentes políticas de permisos disponibles para los recursos compartidos y cómo acceder a las entidades de canalización compartidas e interactuar con ellas mediante llamadas directas a la API a la IA. SageMaker
## Configuración del uso compartido de canalizaciones entre cuentas
SageMaker La IA utiliza [AWS Resource Access Manager](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html) (AWS RAM) para ayudarte a compartir de forma segura las entidades de tu canalización entre cuentas.
### Creación de un recurso compartido
1. Seleccione **Crear un recurso compartido** a través de la [Consola de AWS RAM](https://console.aws.amazon.com/ram/home).
1. Al especificar los detalles del uso compartido de los recursos, elija el tipo de recurso de Canalizaciones y seleccione una o más canalizaciones que desee compartir. Al compartir una canalización con cualquier otra cuenta, también se comparten todas sus ejecuciones de forma implícita.
1. Asocie permisos a un recurso compartido. Elija la política predeterminada de permisos de solo lectura o la política ampliada de permisos de ejecución de canalizaciones. Para obtener información más detallada, consulte [Políticas de permisos para los recursos de Canalizaciones](#build-and-manage-xaccount-permissions).
**nota**
Si seleccionas la política de ejecución de canalizaciones ampliadas, ten en cuenta que cualquier comando de inicio, parada y reintento invocado por cuentas compartidas utiliza recursos de la AWS cuenta que compartió la canalización.
1. Usa la AWS cuenta IDs para especificar las cuentas a las que quieres conceder acceso a tus recursos compartidos.
1. Revise la configuración del recurso compartido y seleccione **Crear recurso compartido**. La asociación del recurso y la entidad principal puede tardar unos minutos en completarse.
Para obtener más información, consulte [Sharing your AWS resources](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html) en la *Guía del usuario de AWS Resource Access Manager*.
### Obtención de respuestas a la invitación para compartir recursos
Una vez establecidas la cuota de recursos y las asociaciones de entidades principales, las cuentas de AWS especificadas reciben una invitación para unirse al recurso compartido. Las AWS cuentas deben aceptar la invitación para acceder a cualquier recurso compartido.
Para obtener más información sobre cómo aceptar una invitación para compartir recursos AWS RAM, consulte [Uso de AWS recursos compartidos](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-shared.html) en la *Guía del usuario de AWS Resource Access Manager*.
## Políticas de permisos para los recursos de Canalizaciones
Al crear tu recurso compartido, elige una de las dos políticas de permisos compatibles para asociarla al tipo de recurso de canalización de SageMaker IA. Ambas políticas permiten el acceso a cualquier canalización seleccionada y a todas sus ejecuciones.
### Permisos predeterminados de solo lectura
La política `AWSRAMDefaultPermissionSageMakerPipeline` permite las siguientes acciones de solo lectura:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:Search"
```
### Permisos ampliados de ejecución de canalización
La política `AWSRAMPermissionSageMakerPipelineAllowExecution` incluye todos los permisos de solo lectura de la política predeterminada y también permite que las cuentas compartidas inicien, detengan y reintenten las ejecuciones de canalizaciones.
**nota**
Ten en cuenta el uso de los AWS recursos cuando utilices la política de permisos de ejecución ampliados de canalización. Con esta política, las cuentas compartidas pueden iniciar, detener y volver a intentar las ejecuciones en canalización. La cuenta propietaria consume todos los recursos utilizados para las ejecuciones de canalizaciones compartidas.
La política ampliada de permisos de ejecución de canalizaciones permite las siguientes acciones:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:StartPipelineExecution"
"sagemaker:StopPipelineExecution"
"sagemaker:RetryPipelineExecution"
"sagemaker:Search"
```
## Acceso a las entidades de canalización compartidas mediante llamadas directas a la API
Una vez que se haya configurado el uso compartido de canalizaciones entre cuentas, puedes ejecutar las siguientes acciones de SageMaker API mediante un ARN de canalización:
**nota**
Solo puede llamar a los comandos de la API si están incluidos en los permisos asociados a su recurso compartido. Si seleccionas la `AWSRAMPermissionSageMakerPipelineAllowExecution` política, los comandos start, stop y retry utilizan los recursos de la AWS cuenta que compartió la canalización.
+ [DescribePipeline](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipeline.html)
+ [DescribePipelineDefinitionForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineDefinitionForExecution.html)
+ [DescribePipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineExecution.html)
+ [ListPipelineExecutions](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutions.html)
+ [ListPipelineExecutionSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutionSteps.html)
+ [ListPipelineParametersForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineParametersForExecution.html)
+ [StartPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StartPipelineExecution.html)
+ [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)
+ [RetryPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RetryPipelineExecution.html)
# Parámetros de canalizaciones
Puede introducir variables en la definición de su canalización mediante parámetros. Puede hacer referencia a los parámetros que defina en la definición de la canalización. Los parámetros tienen un valor predeterminado, que puede anular si especifica valores para los parámetros al iniciar la ejecución de una canalización. El valor predeterminado debe ser una instancia que coincida con el tipo de parámetro. Todos los parámetros utilizados en las definiciones de los pasos deben estar definidos en la definición de la canalización. En este tema, se describen los parámetros que puede definir y cómo implementarlos.
Amazon SageMaker Pipelines admite los siguientes tipos de parámetros:
+ `ParameterString`: representa un parámetro de cadena.
+ `ParameterInteger`: representa un parámetro entero.
+ `ParameterFloat`: representa un parámetro flotante.
+ `ParameterBoolean`: representa un tipo booleano de Python.
Los parámetros tienen el siguiente formato:
```
= (
name="",
default_value=
)
```
El siguiente ejemplo muestra una implementación de parámetro de muestra.
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
ParameterFloat,
ParameterBoolean
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
```
El parámetro se pasa al crear la canalización, tal como se muestra en el siguiente ejemplo.
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count
],
steps=[step_process]
)
```
También puede pasar un valor de parámetro diferente del valor predeterminado a una ejecución de canalización, como se muestra en el ejemplo siguiente.
```
execution = pipeline.start(
parameters=dict(
ProcessingInstanceCount="2",
ModelApprovalStatus="Approved"
)
)
```
Puede manipular parámetros con funciones del SDK de SageMaker Python como`[ sagemaker.workflow.functions.Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.functions.Join)`. Para obtener más información sobre los parámetros, consulte [Parámetros de SageMaker canalizaciones](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#parameters).
[Para conocer las limitaciones conocidas de los parámetros de Pipelines, consulte *[Limitaciones: parametrización en el SDK](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#parameterization)* de Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# Pasos de canalizaciones
Las canalizaciones se componen de pasos. Estos pasos definen las acciones que realiza la canalización y las relaciones entre los pasos mediante propiedades. En la página siguiente, se describen los tipos de pasos, sus propiedades y las relaciones entre ellos.
**Topics**
+ [Adición de un paso](build-and-manage-steps-types.md)
+ [Añadir integración](build-and-manage-steps-integration.md)
+ [Propiedades de paso](#build-and-manage-properties)
+ [Paralelismo de paso](#build-and-manage-parallelism)
+ [Dependencia de datos entre pasos](#build-and-manage-data-dependency)
+ [Dependencia personalizada entre pasos](#build-and-manage-custom-dependency)
+ [Imágenes personalizadas en un paso](#build-and-manage-images)
# Adición de un paso
A continuación, se describen los requisitos de cada tipo de paso y se proporciona un ejemplo de implementación del paso, así como la forma de añadirlo a Canalizaciones. No son implementaciones funcionales porque no proporcionan los recursos y las entradas necesarios. Para ver un tutorial que implemente estos pasos, consulte[Acciones de canalizaciones](pipelines-build.md).
**nota**
También puede crear un paso a partir del código de machine learning local convirtiéndolo en un paso de Canalizaciones con el decorador `@step`. Para obtener más información, consulte [Decorador @step](#step-type-custom).
Amazon SageMaker Pipelines admite los siguientes tipos de pasos:
+ [Ejecutar código](#step-type-executecode)
[Procesando](#step-type-processing)
+ [Formación](#step-type-training)
+ [Ajuste](#step-type-tuning)
+ [AutoML](#step-type-automl)
+ [`Model`](#step-type-model)
+ [`Create model`](#step-type-create-model)
+ [`Register model`](#step-type-register-model)
+ [`Deploy model (endpoint)`](#step-type-deploy-model-endpoint)
+ [Transformar](#step-type-transform)
+ [Condición](#step-type-condition)
+ [`Callback`](#step-type-callback)
+ [Lambda](#step-type-lambda)
+ [`ClarifyCheck`](#step-type-clarify-check)
+ [`QualityCheck`](#step-type-quality-check)
+ [EMR](#step-type-emr)
+ [Trabajo de cuaderno](#step-type-notebook-job)
+ [Fail](#step-type-fail)
## Decorador @step
Si quiere organizar un trabajo de aprendizaje automático personalizado que aproveche las funciones avanzadas de SageMaker IA u otros AWS servicios de la interfaz de usuario de drag-and-drop Pipelines, utilice el. [paso de ejecución del código](#step-type-executecode)
Puede crear un paso a partir del código de machine learning local mediante el decorador `@step`. Después de probar el código, puedes convertir la función en un paso de una canalización de SageMaker IA anotándolo con el decorador. `@step` Canalizaciones crea y ejecuta una canalización al pasar el resultado de la función decorada con`@step` como paso a la canalización. También puedes crear una canalización de DAG de varios pasos que incluya una o más funciones `@step` decoradas, así como los pasos de una canalización de IA tradicional SageMaker . Para obtener más información sobre cómo crear un paso con el decorador `@step`, consulte [Lift-and-shift Código Python con el decorador @step](pipelines-step-decorator.md).
## paso de ejecución del código
En la drag-and-drop interfaz de usuario de Pipelines, puedes usar un paso de ejecución de **código para ejecutar** tu propio código como paso de canalización. Puede cargar una función, un script o un cuaderno de Python para que se ejecute como parte de su canalización. Deberías usar este paso si quieres organizar un trabajo de aprendizaje automático personalizado que aproveche las funciones avanzadas de SageMaker IA u otros servicios. AWS
El paso **Execute Code** carga los archivos a tu bucket de Amazon S3 predeterminado para Amazon SageMaker AI. Es posible que este bucket no tenga establecidos los permisos de uso compartido de recursos entre orígenes (CORS). Para obtener más información sobre cómo configurar permisos de CORS, consulte [Requisito de CORS para datos de imagen de entrada](sms-cors-update.md).
El paso **Ejecutar código** utiliza un trabajo de SageMaker formación de Amazon para ejecutar el código. Asegúrese de que su rol de IAM tenga los permisos de la API `sagemaker:DescribeTrainingJob` y `sagemaker:CreateTrainingJob`. Para obtener más información sobre todos los permisos necesarios para Amazon SageMaker AI y cómo configurarlos, consulte[Permisos de la API de Amazon SageMaker AI: referencia sobre acciones, permisos y recursos](api-permissions-reference.md).
Para añadir un paso de ejecución de código a una canalización mediante el diseñador de canalizaciones, haga lo siguiente:
1. Abre la consola de Amazon SageMaker Studio siguiendo las instrucciones de[Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. Seleccione **En blanco**.
1. En la barra lateral izquierda, seleccione **Ejecutar código** y arrástrelo al lienzo.
1. En el lienzo, elige el paso **Ejecutar código** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**.
1. Puede cargar un solo archivo para ejecutarlo o cargar una carpeta comprimida que contenga varios artefactos.
1. Para cargar un solo archivo, puede proporcionar parámetros opcionales para cuadernos, funciones de Python o scripts.
1. Al proporcionar funciones de Python, se debe proporcionar un controlador en el formato `file.py:`.
1. Para cargar carpetas comprimidas, se deben proporcionar las rutas relativas al código y, si lo desea, puede proporcionar las rutas a un archivo `requirements.txt` o script de inicialización dentro de la carpeta comprimida.
1. Si el lienzo incluye algún paso que preceda inmediatamente al paso **Ejecutar código** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Ejecutar código** para crear un borde.
1. Si el lienzo incluye algún paso que siga inmediatamente al paso **Ejecutar código** que ha añadido, haga clic y arrastre el cursor desde el paso **Ejecutar código** hasta el paso para crear un borde. Se puede hacer referencia a los resultados de los pasos **Ejecutar código** para las funciones de Python.
## Paso de procesamiento
Utilice un paso de procesamiento para crear un trabajo de procesamiento para el procesamiento de datos. Para obtener más información sobre los trabajos de procesamiento, consulte [Process Data and Evaluate Models](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html).
------
#### [ Pipeline Designer ]
Para añadir un paso de procesamiento a una canalización mediante el diseñador de canalizaciones, haga lo siguiente:
1. Abre la consola de Amazon SageMaker Studio siguiendo las instrucciones de[Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. En la barra lateral izquierda, elija **Procesar datos** y arrástrelos al lienzo.
1. En el lienzo, elija el paso **Procesar datos** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**. Para obtener información sobre los campos de estas pestañas, consulte [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep).
1. Si el lienzo incluye algún paso que preceda inmediatamente al paso **Procesar datos** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Procesar datos** para crear un borde.
1. Si el lienzo incluye algún paso que siga inmediatamente al paso **Procesar datos** que ha añadido, haga clic y arrastre el cursor desde el paso **Procesar datos** hasta el paso para crear un borde.
------
#### [ SageMaker Python SDK ]
Un paso de procesamiento requiere un procesador, un script de Python que defina el código de procesamiento, las salidas para el procesamiento y los argumentos del trabajo. El siguiente ejemplo muestra cómo crear una definición de `ProcessingStep`.
```
from sagemaker.sklearn.processing import SKLearnProcessor
sklearn_processor = SKLearnProcessor(framework_version='1.0-1',
role=,
instance_type='ml.m5.xlarge',
instance_count=1)
```
```
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
inputs = [
ProcessingInput(source=, destination="/opt/ml/processing/input"),
]
outputs = [
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
]
step_process = ProcessingStep(
name="AbaloneProcess",
step_args = sklearn_processor.run(inputs=inputs, outputs=outputs,
code="abalone/preprocessing.py")
)
```
**Pasar parámetros de tiempo de ejecución**
El siguiente ejemplo muestra cómo pasar los parámetros de tiempo de ejecución de un PySpark procesador a un`ProcessingStep`.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.spark.processing import PySparkProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
pipeline_session = PipelineSession()
pyspark_processor = PySparkProcessor(
framework_version='2.4',
role=,
instance_type='ml.m5.xlarge',
instance_count=1,
sagemaker_session=pipeline_session,
)
step_args = pyspark_processor.run(
inputs=[ProcessingInput(source=, destination="/opt/ml/processing/input"),],
outputs=[
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
],
code="preprocess.py",
arguments=None,
)
step_process = ProcessingStep(
name="AbaloneProcess",
step_args=step_args,
)
```
Para obtener más información sobre los requisitos de los pasos de procesamiento, consulte [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)documentación. Para ver un ejemplo detallado, consulte el cuaderno de ejemplo [Orchestrate Jobs to Train and Evaluate Models with Amazon SageMaker Pipelines](https://github.com/aws/amazon-sagemaker-examples/blob/62de6a1fca74c7e70089d77e36f1356033adbe5f/sagemaker-pipelines/tabular/abalone_build_train_deploy/sagemaker-pipelines-preprocess-train-evaluate-batch-transform.ipynb). En la sección *Definir un paso de procesamiento para la ingeniería de características* se incluye más información.
------
## Paso de entrenamiento
Puede usar un paso de entrenamiento para crear un trabajo de entrenamiento para entrenar un modelo. Para obtener más información sobre los trabajos de formación, consulte [Entrenar a un modelo con Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
Un paso de entrenamiento requiere un estimador, así como la introducción y la validación de los datos de entrenamiento.
------
#### [ Pipeline Designer ]
Para añadir un paso de entrenamiento a una canalización mediante el diseñador de canalizaciones, haga lo siguiente:
1. Abre la consola de Amazon SageMaker Studio siguiendo las instrucciones de[Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. Seleccione **En blanco**.
1. En la barra lateral izquierda, seleccione **Entrenar modelo** y arrástrelo al lienzo.
1. En el lienzo, elija el paso **Entrenar modelo** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**. Para obtener información sobre los campos de estas pestañas, consulte [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep).
1. Si el lienzo incluye algún paso que preceda inmediatamente al paso **Entrenar modelo** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Entrenar modelo** para crear un borde.
1. Si el lienzo incluye algún paso que siga inmediatamente al paso **Entrenar modelo** que ha añadido, haga clic y arrastre el cursor desde el paso **Entrenar modelo** hasta el paso para crear un borde.
------
#### [ SageMaker Python SDK ]
El siguiente ejemplo muestra cómo crear una definición de `TrainingStep`. Para obtener más información sobre los requisitos de los pasos de entrenamiento, consulte [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep)documentación.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TrainingStep
from sagemaker.xgboost.estimator import XGBoost
pipeline_session = PipelineSession()
xgb_estimator = XGBoost(..., sagemaker_session=pipeline_session)
step_args = xgb_estimator.fit(
inputs={
"train": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train"
].S3Output.S3Uri,
content_type="text/csv"
),
"validation": TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"validation"
].S3Output.S3Uri,
content_type="text/csv"
)
}
)
step_train = TrainingStep(
name="TrainAbaloneModel",
step_args=step_args,
)
```
------
## Paso de ajuste
Se utiliza un paso de ajuste para crear un trabajo de ajuste de hiperparámetros, también conocido como optimización de hiperparámetros (HPO). Un trabajo de ajuste de hiperparámetros ejecuta varios trabajos de entrenamiento, cada uno de los cuales produce una versión del modelo. Para obtener más información sobre el ajuste de hiperparámetros, consulte [Ajuste automático de modelos con IA SageMaker](automatic-model-tuning.md).
El trabajo de ajuste está asociado con el experimento de SageMaker IA que se está llevando a cabo, y los trabajos de formación se crean a modo de pruebas. Para obtener más información, consulte [Integración de experimentos](pipelines-experiments.md).
Un paso de ajuste requiere una [HyperparameterTuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)y aportaciones de formación. Puede volver a entrenar los trabajos de ajuste anteriores si especifica el parámetro `warm_start_config` del `HyperparameterTuner`. Para obtener más información sobre el inicio en caliente y el ajuste de hiperparámetros, consulte [Ejecución de un trabajo de ajuste de hiperparámetros de inicio en caliente](automatic-model-tuning-warm-start.md).
[Se utiliza el método [get\$1top\$1model\$1s3\$1uri del sagemaker.workflow.steps](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep.get_top_model_s3_uri). TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)clase para obtener el artefacto del modelo de una de las versiones del modelo con mejor rendimiento. [Para ver un cuaderno que muestre cómo utilizar un paso de ajuste en una canalización de SageMaker IA, consulta sagemaker-pipelines-tuning-step .ipynb.](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/tuning-step/sagemaker-pipelines-tuning-step.ipynb)
**importante**
Los pasos de ajuste se introdujeron en Amazon SageMaker Python SDK v2.48.0 y Amazon SageMaker Studio Classic v3.8.0. Debe actualizar Studio Classic antes de utilizar un paso de ajuste o no aparecerá el DAG de canalización. Para actualizar Studio Classic, consulte [Cierre y actualice Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
El siguiente ejemplo muestra cómo crear una definición de `TuningStep`.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.tuner import HyperparameterTuner
from sagemaker.inputs import TrainingInput
from sagemaker.workflow.steps import TuningStep
tuner = HyperparameterTuner(..., sagemaker_session=PipelineSession())
step_tuning = TuningStep(
name = "HPTuning",
step_args = tuner.fit(inputs=TrainingInput(s3_data="s3://amzn-s3-demo-bucket/my-data"))
)
```
**Obtención de la mejor versión del modelo**
El siguiente ejemplo muestra cómo obtener la mejor versión del modelo a partir del trabajo de ajuste mediante el método `get_top_model_s3_uri`. A lo sumo, las 50 versiones con mejor rendimiento están disponibles clasificadas según. [HyperParameterTuningJobObjective](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTuningJobObjective.html) El argumento `top_k` es un índice de las versiones, donde `top_k=0` es la versión con mejor rendimiento y `top_k=49` es la versión con peor rendimiento.
```
best_model = Model(
image_uri=image_uri,
model_data=step_tuning.get_top_model_s3_uri(
top_k=0,
s3_bucket=sagemaker_session.default_bucket()
),
...
)
```
Para obtener más información sobre los requisitos de los pasos de ajuste, consulte [sagemaker.workflow.steps. TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)documentación.
## Paso de afinamiento
El ajuste fino entrena un modelo básico previamente entrenado de Amazon SageMaker JumpStart en un nuevo conjunto de datos. Este proceso, también conocido como aprendizaje por transferencia, puede producir modelos precisos con conjuntos de datos más pequeños y con menos tiempo de entrenamiento. Al afinar un modelo, puede usar el conjunto de datos predeterminado o elegir sus propios datos. Para obtener más información sobre cómo ajustar con precisión un modelo base, consulte. JumpStart [Ajuste de un modelo](jumpstart-fine-tune.md)
El paso de ajuste utiliza un trabajo de SageMaker formación de Amazon para personalizar el modelo. Asegúrese de que su rol de IAM tenga los permisos de API `sagemaker:DescribeTrainingJob` y `sagemaker:CreateTrainingJob` para ejecutar el trabajo de afinamiento en su canalización. Para obtener más información sobre los permisos necesarios para Amazon SageMaker AI y cómo configurarlos, consulte[Permisos de la API de Amazon SageMaker AI: referencia sobre acciones, permisos y recursos](api-permissions-reference.md).
Para añadir un paso del **modelo de ajuste** preciso a su proceso mediante el drag-and-drop editor, siga estos pasos:
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. Seleccione **En blanco**.
1. En la barra lateral izquierda, seleccione **Ajustar modelo de forma más precisa** y arrástrelo al lienzo.
1. En el lienzo, elija el paso **Ajustar modelo de forma más precisa** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**.
1. Si el lienzo incluye algún paso que preceda inmediatamente al paso **Ajustar modelo de forma más precisa** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Ajustar modelo de forma más precisa** para crear un borde.
1. Si el lienzo incluye algún paso que siga inmediatamente al paso **Ajustar modelo de forma más precisa** que ha añadido, haga clic y arrastre el cursor desde el paso **Ajustar modelo de forma más precisa** hasta el paso para crear un borde.
## Paso AutoML
Utilice la API de [AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html) para crear un trabajo de AutoML para entrenar automáticamente un modelo. Para obtener más información sobre los trabajos de AutoML, consulte [Automatizar el desarrollo de modelos con Amazon SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html) Autopilot.
**nota**
Actualmente, el paso AutoML solo admite el [modo de entrenamiento de ensamblaje](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-model-support-validation.html).
El siguiente ejemplo muestra cómo crear una definición mediante `AutoMLStep`.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.workflow.automl_step import AutoMLStep
pipeline_session = PipelineSession()
auto_ml = AutoML(...,
role="",
target_attribute_name="my_target_attribute_name",
mode="ENSEMBLING",
sagemaker_session=pipeline_session)
input_training = AutoMLInput(
inputs="s3://amzn-s3-demo-bucket/my-training-data",
target_attribute_name="my_target_attribute_name",
channel_type="training",
)
input_validation = AutoMLInput(
inputs="s3://amzn-s3-demo-bucket/my-validation-data",
target_attribute_name="my_target_attribute_name",
channel_type="validation",
)
step_args = auto_ml.fit(
inputs=[input_training, input_validation]
)
step_automl = AutoMLStep(
name="AutoMLStep",
step_args=step_args,
)
```
**Obtención de la mejor versión del modelo**
El paso AutoML entrena automáticamente a varios candidatos de modelos. Obtenga el modelo con la mejor métrica objetiva del trabajo AutoML utilizando el método `get_best_auto_ml_model` siguiente. También debe utilizar un `role` de IAM para acceder a los artefactos del modelo.
```
best_model = step_automl.get_best_auto_ml_model(role=)
```
Para obtener más información, consulte el paso [AutoML](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.automl_step.AutoMLStep) en el SDK de SageMaker Python.
## Paso de modelo
Utilice a `ModelStep` para crear o registrar un modelo de SageMaker IA. Para obtener más información sobre `ModelStep` los requisitos, consulte [sagemaker.workflow.model\$1step. ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.model_step.ModelStep)documentación.
### Crear un modelo
Puede usar un `ModelStep` para crear un modelo de SageMaker IA. A `ModelStep` requiere artefactos del modelo e información sobre el tipo de instancia de SageMaker IA que necesita usar para crear el modelo. Para obtener más información sobre los modelos de SageMaker IA, consulte [Entrenar un modelo con Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
El siguiente ejemplo muestra cómo crear una definición de `ModelStep`.
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.model import Model
from sagemaker.workflow.model_step import ModelStep
step_train = TrainingStep(...)
model = Model(
image_uri=pytorch_estimator.training_image_uri(),
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
sagemaker_session=PipelineSession(),
role=role,
)
step_model_create = ModelStep(
name="MyModelCreationStep",
step_args=model.create(instance_type="ml.m5.xlarge"),
)
```
### Registrar un modelo
Puede utilizar un `ModelStep` para registrar un `sagemaker.model.Model` o un `sagemaker.pipeline.PipelineModel` en el Registro de SageMaker modelos de Amazon. Un `PipelineModel` representa una canalización de inferencia, que es un modelo compuesto de una secuencia lineal de contenedores que procesan solicitudes de inferencia. Para obtener más información sobre cómo registrar un modelo, consulte [Implementación del registro de modelos con el registro de modelos](model-registry.md).
El siguiente ejemplo muestra cómo crear un `ModelStep` que registre un `PipelineModel`.
```
import time
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.sklearn import SKLearnModel
from sagemaker.xgboost import XGBoostModel
pipeline_session = PipelineSession()
code_location = 's3://{0}/{1}/code'.format(bucket_name, prefix)
sklearn_model = SKLearnModel(
model_data=processing_step.properties.ProcessingOutputConfig.Outputs['model'].S3Output.S3Uri,
entry_point='inference.py',
source_dir='sklearn_source_dir/',
code_location=code_location,
framework_version='1.0-1',
role=role,
sagemaker_session=pipeline_session,
py_version='py3'
)
xgboost_model = XGBoostModel(
model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
entry_point='inference.py',
source_dir='xgboost_source_dir/',
code_location=code_location,
framework_version='0.90-2',
py_version='py3',
sagemaker_session=pipeline_session,
role=role
)
from sagemaker.workflow.model_step import ModelStep
from sagemaker import PipelineModel
pipeline_model = PipelineModel(
models=[sklearn_model, xgboost_model],
role=role,sagemaker_session=pipeline_session,
)
register_model_step_args = pipeline_model.register(
content_types=["application/json"],
response_types=["application/json"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name='sipgroup',
)
step_model_registration = ModelStep(
name="AbaloneRegisterModel",
step_args=register_model_step_args,
)
```
## Paso Crear modelo
El paso Crear modelo se utiliza para crear un modelo de SageMaker IA. Para obtener más información sobre los modelos de SageMaker IA, consulte[Entrena a un modelo con Amazon SageMaker](how-it-works-training.md).
El paso de creación del modelo requiere artefactos del modelo e información sobre el tipo de instancia de SageMaker IA que debe usar para crear el modelo. Los siguientes ejemplos muestran cómo crear una definición del paso Crear modelo. Para obtener más información sobre los requisitos de los pasos para crear un modelo, consulta [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep)documentación.
------
#### [ Pipeline Designer ]
Para añadir un paso de creación de modelo a su canalización, haga lo siguiente:
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. Seleccione **En blanco**.
1. En la barra lateral izquierda, seleccione **Crear modelo** y arrástrelo al lienzo.
1. En el lienzo, elija el paso **Crear modelo** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**. Para obtener información sobre los campos de estas pestañas, consulte [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep).
1. Si el lienzo incluye algún paso que preceda inmediatamente al paso **Crear modelo** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Crear modelo** para crear un borde.
1. Si el lienzo incluye algún paso que siga inmediatamente al paso **Crear modelo** que ha añadido, haga clic y arrastre el cursor desde el paso **Crear modelo** hasta el paso para crear un borde.
------
#### [ SageMaker Python SDK ]
**importante**
Recomendamos usarlo [Paso de modelo](#step-type-model) para crear modelos a partir de la versión 2.90.0 del SDK de SageMaker Python para IA. `CreateModelStep`seguirá funcionando en las versiones anteriores del SDK de SageMaker Python, pero ya no es compatible activamente.
```
from sagemaker.workflow.steps import CreateModelStep
step_create_model = CreateModelStep(
name="AbaloneCreateModel",
model=best_model,
inputs=inputs
)
```
------
## Paso Registrar modelo
El paso Registrar el modelo registra un modelo en el Registro de SageMaker modelos.
------
#### [ Pipeline Designer ]
Para registrar un modelo desde una canalización mediante el diseñador de canalizaciones, haga lo siguiente:
1. Abre la consola de Amazon SageMaker Studio siguiendo las instrucciones de[Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. Seleccione **En blanco**.
1. En la barra lateral izquierda, seleccione **Registrar modelo** y arrástrelo al lienzo.
1. En el lienzo, elija el paso **Registrar modelo** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**. Para obtener información sobre los campos de estas pestañas, consulte [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel).
1. Si el lienzo incluye algún paso que preceda inmediatamente al paso **Registrar modelo** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Registrar modelo** para crear un borde.
1. Si el lienzo incluye algún paso que siga inmediatamente al paso **Registrar modelo** que ha añadido, haga clic y arrastre el cursor desde el paso **Registrar modelo** hasta el paso para crear un borde.
------
#### [ SageMaker Python SDK ]
**importante**
Recomendamos usarlo [Paso de modelo](#step-type-model) para registrar modelos a partir de la versión 2.90.0 del SDK de SageMaker Python para IA. `RegisterModel`seguirá funcionando en las versiones anteriores del SDK de SageMaker Python, pero ya no es compatible activamente.
[Debe seguir un `RegisterModel` paso para registrar un Sagemaker.Model.model o un [sagemaker.pipeline](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html). PipelineModel](https://sagemaker.readthedocs.io/en/stable/api/inference/pipeline.html#pipelinemodel)con el Registro de SageMaker modelos de Amazon. Un `PipelineModel` representa una canalización de inferencia, que es un modelo compuesto de una secuencia lineal de contenedores que procesan solicitudes de inferencia.
Para obtener más información sobre cómo registrar un modelo, consulte [Implementación del registro de modelos con el registro de modelos](model-registry.md). Para obtener más información sobre los requisitos de los `RegisterModel` pasos, consulte [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel)documentación.
El siguiente ejemplo muestra cómo crear un paso `RegisterModel` que registre un `PipelineModel`.
```
import time
from sagemaker.sklearn import SKLearnModel
from sagemaker.xgboost import XGBoostModel
code_location = 's3://{0}/{1}/code'.format(bucket_name, prefix)
sklearn_model = SKLearnModel(model_data=processing_step.properties.ProcessingOutputConfig.Outputs['model'].S3Output.S3Uri,
entry_point='inference.py',
source_dir='sklearn_source_dir/',
code_location=code_location,
framework_version='1.0-1',
role=role,
sagemaker_session=sagemaker_session,
py_version='py3')
xgboost_model = XGBoostModel(model_data=training_step.properties.ModelArtifacts.S3ModelArtifacts,
entry_point='inference.py',
source_dir='xgboost_source_dir/',
code_location=code_location,
framework_version='0.90-2',
py_version='py3',
sagemaker_session=sagemaker_session,
role=role)
from sagemaker.workflow.step_collections import RegisterModel
from sagemaker import PipelineModel
pipeline_model = PipelineModel(models=[sklearn_model,xgboost_model],role=role,sagemaker_session=sagemaker_session)
step_register = RegisterModel(
name="AbaloneRegisterModel",
model=pipeline_model,
content_types=["application/json"],
response_types=["application/json"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name='sipgroup',
)
```
Si no se proporciona el `model`, el paso de registro del modelo requiere un estimador, como se muestra en el ejemplo siguiente.
```
from sagemaker.workflow.step_collections import RegisterModel
step_register = RegisterModel(
name="AbaloneRegisterModel",
estimator=xgb_train,
model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
content_types=["text/csv"],
response_types=["text/csv"],
inference_instances=["ml.t2.medium", "ml.m5.xlarge"],
transform_instances=["ml.m5.xlarge"],
model_package_group_name=model_package_group_name,
approval_status=model_approval_status,
model_metrics=model_metrics
)
```
------
## Paso Implementar modelo (puntos de conexión)
En el diseñador de canalizaciones, utilice el paso Implementar modelo (punto de conexión) para implementar el modelo en un punto de conexión. Puede crear un nuevo punto de conexión o utilizar un punto de conexión existente. La inferencia en tiempo real es idónea para cargas de trabajo de inferencia con requisitos en tiempo real, interactivos y de baja latencia. Puede implementar su modelo en los servicios de alojamiento de SageMaker IA y obtener un punto final en tiempo real que pueda usarse como inferencia. Estos puntos de conexión están totalmente administrados y admiten escalado automático. Para obtener más información sobre la inferencia en tiempo real en la SageMaker IA, consulte. [Inferencia en tiempo real](realtime-endpoints.md)
Antes de añadir un paso del modelo de implementación a su canalización, asegúrese de que su rol de IAM tenga los siguientes permisos:
+ `sagemaker:CreateModel`
+ `sagemaker:CreateEndpointConfig`
+ `sagemaker:CreateEndpoint`
+ `sagemaker:UpdateEndpoint`
+ `sagemaker:DescribeModel`
+ `sagemaker:DescribeEndpointConfig`
+ `sagemaker:DescribeEndpoint`
Para obtener más información sobre todos los permisos necesarios para la SageMaker IA y cómo configurarlos, consulte[Permisos de la API de Amazon SageMaker AI: referencia sobre acciones, permisos y recursos](api-permissions-reference.md).
Para añadir un paso de despliegue modelo a tu canalización en el drag-and-drop editor, sigue estos pasos:
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. Seleccione **En blanco**.
1. En la barra lateral izquierda, seleccione **Implementar modelo (punto de conexión)** y arrástrelo al lienzo.
1. En el lienzo, elija el paso **Implementar modelo (punto de conexión)** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**.
1. Si el lienzo incluye algún paso que precede inmediatamente al paso **Implementar modelo (punto de conexión)** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Implementar modelo (punto de conexión)** para crear un borde.
1. Si el lienzo incluye algún paso que sigue inmediatamente al paso **Implementar modelo (punto de conexión)** que ha añadido, haga clic y arrastre el cursor desde el paso **Implementar modelo (punto de conexión)** hasta el paso para crear un borde.
## Paso de transformación
Utilice un paso de transformación por lotes para ejecutar la inferencia en todo un conjunto de datos. Para obtener más información acerca de la transformación por lotes, consulte [Transformaciones por lotes con canalizaciones de inferencia](inference-pipeline-batch.md).
Un paso de transformación requiere un transformador y los datos sobre los que se ejecutará la transformación por lotes. El siguiente ejemplo muestra cómo crear una definición del paso Transformar. Para obtener más información sobre los requisitos de los pasos de transformación, consulta [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep)documentación.
------
#### [ Pipeline Designer ]
Para añadir un paso de transformación por lotes a tu proceso mediante el editor drag-and-drop visual, haz lo siguiente:
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. Seleccione **En blanco**.
1. En la barra lateral izquierda, seleccione **Implementar modelo (transformación por lotes)** y arrástrelo al lienzo.
1. En el lienzo, elija el paso **Implementar modelo (transformación por lotes)** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**. Para obtener información sobre los campos de estas pestañas, consulta [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep).
1. Si el lienzo incluye algún paso que precede inmediatamente al paso **Implementar modelo (transformación por lotes)** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Implementar modelo (transformación por lotes)** para crear un borde.
1. Si el lienzo incluye algún paso que sigue inmediatamente al paso **Implementar modelo (transformación por lotes)** que ha añadido, haga clic y arrastre el cursor desde el paso **Implementar modelo (transformación por lotes)** hasta el paso para crear un borde.
------
#### [ SageMaker Python SDK ]
```
from sagemaker.workflow.pipeline_context import PipelineSession
from sagemaker.transformer import Transformer
from sagemaker.inputs import TransformInput
from sagemaker.workflow.steps import TransformStep
transformer = Transformer(..., sagemaker_session=PipelineSession())
step_transform = TransformStep(
name="AbaloneTransform",
step_args=transformer.transform(data="s3://amzn-s3-demo-bucket/my-data"),
)
```
------
## Paso de condición
Se utiliza un paso de condición para evaluar la condición de las propiedades del paso y evaluar qué acción se debe realizar a continuación en la canalización.
Un paso de condición requiere lo siguiente:
+ Una lista de condiciones.
+ Una lista de pasos que se van a ejecutar si la condición se evalúa en `true`.
+ Una lista de pasos que se van a ejecutar si la condición se evalúa en `false`.
------
#### [ Pipeline Designer ]
Para añadir un paso de condición a una canalización mediante el diseñador de canalizaciones, haga lo siguiente:
1. Abre la consola de Amazon SageMaker Studio siguiendo las instrucciones de[Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. Seleccione **En blanco**.
1. En la barra lateral izquierda, elija **Condición** y arrástrela al lienzo.
1. En el lienzo, elija el paso **Condición** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**. Para obtener información sobre los campos de estas pestañas, consulte [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.condition_step.ConditionStep).
1. Si el lienzo incluye algún paso que preceda inmediatamente al paso **Condición** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Condición** para crear un borde.
1. Si el lienzo incluye algún paso que siga inmediatamente al paso **Condición** que ha añadido, haga clic y arrastre el cursor desde el paso **Condición** hasta el paso para crear un borde.
------
#### [ SageMaker Python SDK ]
El siguiente ejemplo muestra cómo crear una definición de `ConditionStep`.
**Limitaciones**
+ Las canalizaciones no admiten el uso de pasos de condición anidados. No puede pasar un paso de condición como entrada para otro paso de condición.
+ Un paso de condición no puede usar pasos idénticos en ambas ramas. Si necesita la misma funcionalidad de paso en ambas ramas, duplique el paso y asígnele un nombre diferente.
```
from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=evaluation_report,
json_path="regression_metrics.mse.value"
),
right=6.0
)
step_cond = ConditionStep(
name="AbaloneMSECond",
conditions=[cond_lte],
if_steps=[step_register, step_create_model, step_transform],
else_steps=[]
)
```
Para obtener más información sobre `ConditionStep` los requisitos, consulte [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#conditionstep) Referencia de API. Para obtener más información sobre las condiciones admitidas, consulte *[Amazon SageMaker Pipelines: Condiciones](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#conditions)* en la documentación del SDK de Python para SageMaker IA.
------
## Paso de devolución de llamada
Utilice un `Callback` paso para añadir procesos y AWS servicios adicionales a su flujo de trabajo que Amazon SageMaker Pipelines no proporcione directamente. Cuando se ejecuta un paso `Callback`, se lleva a cabo el siguiente procedimiento:
+ Canalizaciones envía un mensaje a una cola de Amazon Simple Queue Service (Amazon SQS) especificada por el cliente. El mensaje contiene un token generado por Canalizaciones y una lista de parámetros de entrada proporcionada por el cliente. Tras enviar el mensaje, Canalizaciones espera una respuesta del cliente.
+ El cliente recupera el mensaje de la cola de Amazon SQS e inicia su proceso personalizado.
+ Cuando finaliza el proceso, el cliente llama a una de las siguientes direcciones APIs y envía el token generado por Pipelines:
+ [SendPipelineExecutionStepSuccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepSuccess.html), junto con una lista de parámetros de salida
+ [SendPipelineExecutionStepFailure](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepFailure.html), junto con el motivo del fallo
+ La llamada a la API hace que Canalizaciones continúe con el proceso de canalización o produzcan un error.
Para obtener más información sobre los requisitos de los `Callback` pasos, consulte [sagemaker.workflow.callback\$1step. CallbackStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.callback_step.CallbackStep)documentación. Para obtener una solución completa, consulte [Ampliar los SageMaker canales para incluir pasos personalizados mediante pasos de devolución de llamadas](https://aws.amazon.com/blogs/machine-learning/extend-amazon-sagemaker-pipelines-to-include-custom-steps-using-callback-steps/).
**importante**
`Callback`los pasos se introdujeron en Amazon SageMaker Python SDK v2.45.0 y Amazon SageMaker Studio Classic v3.6.2. Debe actualizar Studio Classic antes de utilizar un paso `Callback` o no aparecerá el DAG de canalización. Para actualizar Studio Classic, consulte [Cierre y actualice Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
En el siguiente ejemplo, se muestra una implementación del procedimiento anterior.
```
from sagemaker.workflow.callback_step import CallbackStep
step_callback = CallbackStep(
name="MyCallbackStep",
sqs_queue_url="https://sqs.us-east-2.amazonaws.com/012345678901/MyCallbackQueue",
inputs={...},
outputs=[...]
)
callback_handler_code = '
import boto3
import json
def handler(event, context):
sagemaker_client=boto3.client("sagemaker")
for record in event["Records"]:
payload=json.loads(record["body"])
token=payload["token"]
# Custom processing
# Call SageMaker AI to complete the step
sagemaker_client.send_pipeline_execution_step_success(
CallbackToken=token,
OutputParameters={...}
)
'
```
**nota**
Los parámetros de salida para `CallbackStep` no deben estar anidados. Por ejemplo, si utiliza un diccionario anidado como parámetro de salida, el diccionario se trata como una cadena única (p. ej. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Si proporciona un valor anidado, cuando intenta hacer referencia a un parámetro de salida concreto, la SageMaker IA arroja un error de cliente que no se puede volver a intentar.
**Comportamiento de detención**
Un proceso de canalización no se detiene mientras se ejecuta un paso `Callback`.
Cuando llamas a un proceso de canalización con un `Callback` paso [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)en ejecución, Pipelines envía un mensaje de Amazon SQS a la cola de SQS. El cuerpo del mensaje de SQS contiene un campo **Estado**, que se establece en `Stopping`. En el siguiente ejemplo se muestra un cuerpo de mensaje SQS.
```
{
"token": "26vcYbeWsZ",
"pipelineExecutionArn": "arn:aws:sagemaker:us-east-2:012345678901:pipeline/callback-pipeline/execution/7pinimwddh3a",
"arguments": {
"number": 5,
"stringArg": "some-arg",
"inputData": "s3://sagemaker-us-west-2-012345678901/abalone/abalone-dataset.csv"
},
"status": "Stopping"
}
```
Debe añadir lógica a su consumidor de mensajes de Amazon SQS para tomar las medidas necesarias (por ejemplo, limpiar los recursos) al recibir el mensaje. A continuación, añada una llamada a `SendPipelineExecutionStepSuccess` o `SendPipelineExecutionStepFailure`.
Solo cuando Canalizaciones recibe una de estas llamadas detiene el proceso de canalización.
## Paso de Lambda
Se utiliza un paso Lambda para ejecutar una AWS Lambda función. Puede ejecutar una función Lambda existente o la SageMaker IA puede crear y ejecutar una función Lambda nueva. Si decide utilizar una función Lambda existente, debe estar en la Región de AWS misma línea que la canalización de SageMaker IA. [Para ver un cuaderno que muestre cómo usar un paso de Lambda en una canalización de SageMaker IA, consulte sagemaker-pipelines-lambda-step .ipynb.](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/lambda-step/sagemaker-pipelines-lambda-step.ipynb)
**importante**
Los pasos de Lambda se introdujeron en Amazon SageMaker Python SDK v2.51.0 y Amazon SageMaker Studio Classic v3.9.1. Debe actualizar Studio Classic antes de utilizar un paso Lambda o no aparecerá el DAG de canalización. Para actualizar Studio Classic, consulte [Cierre y actualice Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
SageMaker AI proporciona la [clase SageMaker.Lambda\$1Helper.Lambda para crear, actualizar, invocar y eliminar funciones Lambda](https://sagemaker.readthedocs.io/en/stable/api/utility/lambda_helper.html). `Lambda`tiene la siguiente firma.
```
Lambda(
function_arn, # Only required argument to invoke an existing Lambda function
# The following arguments are required to create a Lambda function:
function_name,
execution_role_arn,
zipped_code_dir, # Specify either zipped_code_dir and s3_bucket, OR script
s3_bucket, # S3 bucket where zipped_code_dir is uploaded
script, # Path of Lambda function script
handler, # Lambda handler specified as "lambda_script.lambda_handler"
timeout, # Maximum time the Lambda function can run before the lambda step fails
...
)
```
El [sagemaker.workflow.lambda\$1step. LambdaStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.lambda_step.LambdaStep)la clase tiene un argumento de tipo. `lambda_func` `Lambda` Para invocar una función de Lambda existente, el único requisito es proporcionar el nombre de recurso de Amazon (ARN) de la función al `function_arn`. Si no proporciona un valor para `function_arn`, debe especificar el `handler` y una de las siguientes opciones:
+ `zipped_code_dir`: la ruta de la función de Lambda comprimida
`s3_bucket`: el bucket de Amazon S3 donde se va a cargar `zipped_code_dir`
+ `script`: la ruta del archivo de script de la función de Lambda
El siguiente ejemplo muestra cómo crear una definición de paso `Lambda` que invoque una función de Lambda existente.
```
from sagemaker.workflow.lambda_step import LambdaStep
from sagemaker.lambda_helper import Lambda
step_lambda = LambdaStep(
name="ProcessingLambda",
lambda_func=Lambda(
function_arn="arn:aws:lambda:us-west-2:012345678910:function:split-dataset-lambda"
),
inputs={
s3_bucket = s3_bucket,
data_file = data_file
},
outputs=[
"train_file", "test_file"
]
)
```
El siguiente ejemplo muestra cómo crear una definición de paso `Lambda` que cree e invoque una función de Lambda mediante un script de función de Lambda.
```
from sagemaker.workflow.lambda_step import LambdaStep
from sagemaker.lambda_helper import Lambda
step_lambda = LambdaStep(
name="ProcessingLambda",
lambda_func=Lambda(
function_name="split-dataset-lambda",
execution_role_arn=execution_role_arn,
script="lambda_script.py",
handler="lambda_script.lambda_handler",
...
),
inputs={
s3_bucket = s3_bucket,
data_file = data_file
},
outputs=[
"train_file", "test_file"
]
)
```
**Entradas y salidas**
Si la función `Lambda` tiene entradas o salidas, estas también deben definirse en el paso `Lambda`.
**nota**
Los parámetros de entrada y salida no deben estar anidados. Por ejemplo, si utiliza un diccionario anidado como parámetro de salida, el diccionario se trata como una cadena única (p. ej. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Si proporciona un valor anidado e intenta consultarlo más adelante, se produce un error de cliente indicando que no se puede volver a intentar.
Al definir el paso `Lambda`, `inputs` debe se un diccionario de pares clave-valor. Cada valor del diccionario de `inputs` debe ser de un tipo primitivo (cadena, entero o flotante). No se admiten objetos anidados. Si no se define, el valor de `inputs` predeterminado es `None`.
El valor de `outputs` debe ser una lista de claves. Estas claves hacen referencia a un diccionario definido en la salida de la función `Lambda`. Como en `inputs`, estas claves deben ser de tipos primitivos y no se admiten objetos anidados.
**Comportamiento de tiempo de espera y detención**
La clase `Lambda` tiene un argumento `timeout` que especifica el tiempo máximo que puede ejecutarse la función de Lambda. El valor predeterminado es de 120 segundos, con un máximo de 10 minutos. Si la función de Lambda se está ejecutando cuando se alcanza el tiempo de espera, el paso Lambda producirá un erro; sin embargo, la función de Lambda seguirá ejecutándose.
No se puede detener un proceso de canalización mientras se está ejecutando un paso Lambda porque la función de Lambda invocada por el paso Lambda no se puede detener. Si detiene el proceso mientras se ejecuta la función de Lambda, la canalización esperará a que finalice la función o hasta que se agote el tiempo de espera. Esto depende de lo que ocurra primero. A continuación, el proceso se detiene. Si la función de Lambda finaliza, el estado del proceso de canalización es `Stopped`. Si se agota el tiempo de espera, el estado del proceso de canalización es `Failed`.
## ClarifyCheck paso
Puede utilizar el paso `ClarifyCheck` para comprobar la desviación de la referencia con respecto a las líneas de base anteriores para analizar los sesgos y la explicabilidad del modelo. A continuación, puede generar y [registrar las líneas de base](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) con el método `model.register()` y pasar la salida de ese método a [Paso de modelo](#step-type-model) con `[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)`. Amazon SageMaker Model Monitor puede utilizar estas líneas base para la comprobación de desviaciones para los puntos finales de su modelo. Como resultado, no necesita hacer una sugerencia de [referencia](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) por separado.
El paso `ClarifyCheck` también permite extraer líneas de base para la comprobación de desviaciones del registro del modelo. En este `ClarifyCheck` paso se utiliza el contenedor prediseñado de SageMaker Clarify. Este contenedor proporciona una serie de capacidades de supervisión de modelos, incluida la sugerencia de restricciones y la validación de restricciones con respecto a una referencia determinada. Para obtener más información, consulte [Contenedores SageMaker Clarify prediseñados](clarify-processing-job-configure-container.md).
### Configurar el paso ClarifyCheck
Puede configurar el paso `ClarifyCheck` para que realice solo uno de los siguientes tipos de comprobaciones cada vez que se utilice en una canalización.
+ Verificación del sesgo de datos
+ Verificación del sesgo del modelo
+ Verificación de la explicabilidad del modelo
Para ello, defina el parámetro `clarify_check_config` con uno de los siguientes valores de tipo de comprobación:
+ `DataBiasCheckConfig`
+ `ModelBiasCheckConfig`
+ `ModelExplainabilityCheckConfig`
El `ClarifyCheck` paso inicia un trabajo de procesamiento que ejecuta el contenedor prediseñado de SageMaker AI Clarify y requiere [configuraciones específicas para la comprobación y el trabajo de procesamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-configure-processing-jobs.html). `ClarifyCheckConfig`y `CheckJobConfig` son funciones auxiliares para estas configuraciones. Estas funciones auxiliares están alineadas con la forma en que el trabajo de procesamiento de SageMaker Clarify calcula para comprobar el sesgo del modelo, el sesgo de los datos o la explicabilidad del modelo. Para obtener más información, consulte [Ejecute SageMaker Clarify Processing Jobs para analizar los sesgos y facilitar la explicación](clarify-processing-job-run.md).
### Control del comportamiento del paso para comprobaciones de desviación
El paso `ClarifyCheck` requiere los dos indicadores booleanos siguientes para controlar su comportamiento:
+ `skip_check`: este parámetro indica si se omite o no la comprobación de desviaciones con respecto a la referencia anterior. Si se establece en `False`, debe estar disponible la referencia anterior del tipo de comprobación configurado.
+ `register_new_baseline`: este parámetro indica si se puede acceder a una referencia recién calculada mediante la propiedad de paso `BaselineUsedForDriftCheckConstraints`. Si se establece en `False`, también debe estar disponible la referencia anterior del tipo de comprobación configurado. Se puede acceder a ella a través de la propiedad `BaselineUsedForDriftCheckConstraints`.
Para obtener más información, consulte [Cálculo de referencia, detección de desviaciones y ciclo de vida con Amazon SageMaker Pipelines ClarifyCheck y QualityCheck pasos](pipelines-quality-clarify-baseline-lifecycle.md).
### Trabajo con líneas de base
Puede especificar `model_package_group_name` para localizar la referencia existente. A continuación, el paso `ClarifyCheck` extrae `DriftCheckBaselines` en el último paquete de modelos aprobado del grupo de paquetes de modelos.
O bien, puede proporcionar una referencia anterior a través del parámetro `supplied_baseline_constraints`. Si especifica tanto `model_package_group_name` como `supplied_baseline_constraints`, el paso `ClarifyCheck` utiliza la referencia especificada por el parámetro `supplied_baseline_constraints`.
[Para obtener más información sobre el uso de los requisitos de los `ClarifyCheck` pasos, consulte sagemaker.workflow.steps. ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.clarify_check_step.ClarifyCheckStep)en el *Amazon SageMaker SageMaker AI SDK para Python*. Para ver un bloc de notas clásico de Amazon SageMaker Studio que muestre cómo usar `ClarifyCheck` step in Pipelines, consulta [sagemaker-pipeline-model-monitor-clarify-steps.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/model-monitor-clarify-pipelines/sagemaker-pipeline-model-monitor-clarify-steps.ipynb).
**Example Creación de un paso `ClarifyCheck` para la comprobación del sesgo de los datos**
```
from sagemaker.workflow.check_job_config import CheckJobConfig
from sagemaker.workflow.clarify_check_step import DataBiasCheckConfig, ClarifyCheckStep
from sagemaker.workflow.execution_variables import ExecutionVariables
check_job_config = CheckJobConfig(
role=role,
instance_count=1,
instance_type="ml.c5.xlarge",
volume_size_in_gb=120,
sagemaker_session=sagemaker_session,
)
data_bias_data_config = DataConfig(
s3_data_input_path=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
s3_output_path=Join(on='/', values=['s3:/', your_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'databiascheckstep']),
label=0,
dataset_type="text/csv",
s3_analysis_config_output_path=data_bias_analysis_cfg_output_path,
)
data_bias_config = BiasConfig(
label_values_or_threshold=[15.0], facet_name=[8], facet_values_or_threshold=[[0.5]]
)
data_bias_check_config = DataBiasCheckConfig(
data_config=data_bias_data_config,
data_bias_config=data_bias_config,
)h
data_bias_check_step = ClarifyCheckStep(
name="DataBiasCheckStep",
clarify_check_config=data_bias_check_config,
check_job_config=check_job_config,
skip_check=False,
register_new_baseline=False
supplied_baseline_constraints="s3://sagemaker-us-west-2-111122223333/baseline/analysis.json",
model_package_group_name="MyModelPackageGroup"
)
```
## QualityCheck paso
Utilice el paso `QualityCheck` para realizar [sugerencias de referencia](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) y comprobar las desviaciones con respecto a una referencia anterior para determinar la calidad de los datos o la calidad del modelo en una canalización. A continuación, puede generar y [registrar las referencias](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) con el método `model.register()` y pasar la salida de ese método a [Paso de modelo](#step-type-model) con `[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)`.
El monitor de modelos utiliza estas referencias para la comprobación de desviaciones en los puntos de conexión del modelo, de manera que no sea necesario hacer una sugerencia de referencia aparte. El paso `QualityCheck` también permite extraer líneas de base para la comprobación de desviaciones del registro del modelo. El `QualityCheck` paso aprovecha el contenedor prediseñado de Amazon SageMaker AI Model Monitor. Este contenedor dispone de una serie de funciones de supervisión del modelo que incluyen la sugerencia de restricciones, la generación de estadísticas y la validación de restricciones con respecto a una referencia. Para obtener más información, consulte [Contenedor prediseñado de Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md).
### Configurar el paso QualityCheck
Puede configurar el paso `QualityCheck` para que ejecute solo uno de los siguientes tipos de comprobaciones cada vez que se utilice en una canalización.
+ Verificación de la calidad de los datos
+ Control de la calidad del modelo
Para ello, defina el parámetro `quality_check_config` con uno de los siguientes valores de tipo de comprobación:
+ `DataQualityCheckConfig`
+ `ModelQualityCheckConfig`
El paso `QualityCheck` inicia un trabajo de procesamiento que ejecuta el contenedor prediseñado del monitor de modelos y requiere configuraciones específicas para el trabajo de verificación y procesamiento. `QualityCheckConfig` y `CheckJobConfig` son funciones auxiliares para estas configuraciones. Estas funciones auxiliares están alineadas con la forma en que el Monitor de modelos crea una referencia para supervisar la calidad del modelo o la calidad de los datos. Para obtener más información sobre las sugerencias de referencia del monitor de modelos, consulte [Crear una referencia](model-monitor-create-baseline.md) y [Creación de una referencia de calidad del modelo](model-monitor-model-quality-baseline.md).
### Control del comportamiento del paso para comprobaciones de desviación
El paso `QualityCheck` requiere los dos indicadores booleanos siguientes para controlar su comportamiento:
+ `skip_check`: este parámetro indica si se omite o no la comprobación de desviaciones con respecto a la referencia anterior. Si se establece en `False`, debe estar disponible la referencia anterior del tipo de comprobación configurado.
+ `register_new_baseline`: este parámetro indica si se puede acceder a una referencia recién calculada mediante las propiedad de paso `BaselineUsedForDriftCheckConstraints` y `BaselineUsedForDriftCheckStatistics`. Si se establece en `False`, también debe estar disponible la referencia anterior del tipo de comprobación configurado. Se puede acceder a ella a través de las propiedades `BaselineUsedForDriftCheckConstraints` y `BaselineUsedForDriftCheckStatistics`.
Para obtener más información, consulte [Cálculo de referencia, detección de desviaciones y ciclo de vida con Amazon SageMaker Pipelines ClarifyCheck y QualityCheck pasos](pipelines-quality-clarify-baseline-lifecycle.md).
### Trabajo con líneas de base
Puede especificar una referencia anterior directamente a través de los parámetros `supplied_baseline_statistics` y `supplied_baseline_constraints`. También puede especificar `model_package_group_name` y el paso `QualityCheck` extrae las `DriftCheckBaselines` del paquete de modelos aprobado más reciente del grupo de paquetes de modelos.
Cuando especifica lo siguiente, el paso `QualityCheck` utiliza la referencia especificada por `supplied_baseline_constraints` y `supplied_baseline_statistics` en el tipo de comprobación del paso `QualityCheck`.
+ `model_package_group_name`
+ `supplied_baseline_constraints`
+ `supplied_baseline_statistics`
Para obtener más información sobre el uso de los requisitos del `QualityCheck` paso, consulte [sagemaker.workflow.steps. QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.quality_check_step.QualityCheckStep)en el *Amazon SageMaker SageMaker AI SDK para Python*. Para ver un bloc de notas clásico de Amazon SageMaker Studio que muestre cómo usar `QualityCheck` step in Pipelines, consulta [sagemaker-pipeline-model-monitor-clarify-steps.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/model-monitor-clarify-pipelines/sagemaker-pipeline-model-monitor-clarify-steps.ipynb).
**Example Creación de un paso `QualityCheck` para la comprobación de la calidad de los datos**
```
from sagemaker.workflow.check_job_config import CheckJobConfig
from sagemaker.workflow.quality_check_step import DataQualityCheckConfig, QualityCheckStep
from sagemaker.workflow.execution_variables import ExecutionVariables
check_job_config = CheckJobConfig(
role=role,
instance_count=1,
instance_type="ml.c5.xlarge",
volume_size_in_gb=120,
sagemaker_session=sagemaker_session,
)
data_quality_check_config = DataQualityCheckConfig(
baseline_dataset=step_process.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
dataset_format=DatasetFormat.csv(header=False, output_columns_position="START"),
output_s3_uri=Join(on='/', values=['s3:/', your_bucket, base_job_prefix, ExecutionVariables.PIPELINE_EXECUTION_ID, 'dataqualitycheckstep'])
)
data_quality_check_step = QualityCheckStep(
name="DataQualityCheckStep",
skip_check=False,
register_new_baseline=False,
quality_check_config=data_quality_check_config,
check_job_config=check_job_config,
supplied_baseline_statistics="s3://sagemaker-us-west-2-555555555555/baseline/statistics.json",
supplied_baseline_constraints="s3://sagemaker-us-west-2-555555555555/baseline/constraints.json",
model_package_group_name="MyModelPackageGroup"
)
```
## Paso EMR
Utilice el paso [EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html) de Amazon SageMaker Pipelines para:
+ Procesar los [pasos de Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-work-with-steps.html) en un clúster de Amazon EMR en ejecución.
+ Hacer que la canalización cree y administre un clúster de Amazon EMR por usted.
Para obtener más información sobre Amazon EMR, consulte [Introducción a Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html).
El paso EMR requiere que `EMRStepConfig` incluya la ubicación del archivo JAR que utilizará el clúster de Amazon EMR y cualquier argumento que se vaya a pasar. También debe proporcionar el ID del clúster de Amazon EMR si desea ejecutar el paso en un clúster de EMR en ejecución. También puede pasar la configuración del clúster para ejecutar el paso EMR en un clúster que cree, administre y finalice en su nombre. Las siguientes secciones incluyen ejemplos y enlaces a cuadernos de muestra que muestran ambos métodos.
**nota**
Los pasos EMR requieren que el rol transferido a su canalización tenga permisos adicionales. Asocie la [política administrada de AWS : `AmazonSageMakerPipelinesIntegrations`](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol-pipelines.html#security-iam-awsmanpol-AmazonSageMakerPipelinesIntegrations) a su rol de canalización o asegúrese de que el rol incluya los permisos de esa política.
Si procesa un paso EMR en un clúster en ejecución, solo podrá usar un clúster que se encuentre en uno de los siguientes estados:
`STARTING`
`BOOTSTRAPPING`
`RUNNING`
`WAITING`
Si procesa los pasos EMR en un clúster en ejecución, puede tener como máximo 256 pasos EMR en un estado `PENDING` en un clúster de EMR. Los pasos EMR enviados por encima de este límite provocan un error en la ejecución de la canalización. Puede plantearse usar [Política de reintentos para los pasos de la canalización](pipelines-retry-policy.md).
Especifique el ID del clúster o la configuración del clúster, pero no ambos.
El paso de EMR depende de Amazon EventBridge para monitorear los cambios en el paso de EMR o en el estado del clúster. Si procesa su trabajo de Amazon EMR en un clúster en ejecución, el paso EMR utiliza la regla `SageMakerPipelineExecutionEMRStepStatusUpdateRule` para supervisar el estado del paso EMR. Si procesa su trabajo en un clúster que el paso EMR cree en su nombre, el paso usa la regla `SageMakerPipelineExecutionEMRClusterStatusRule` para supervisar los cambios en el estado del clúster. Si ve alguna de estas EventBridge reglas en su AWS cuenta, no la elimine o, de lo contrario, es posible que su paso de EMR no se complete.
**Añada un paso de Amazon EMR a su proceso**
Para añadir un paso de EMR a tu canalización, haz lo siguiente:
+ Abre la consola de Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ En el panel de navegación izquierdo, seleccione **Canalizaciones**.
+ Seleccione **Crear**.
+ Seleccione **En blanco**.
+ En la barra lateral izquierda, elija **Procesar datos** y arrástrelos al lienzo.
+ En el lienzo, elija el paso **Procesar datos** que ha añadido.
+ En la barra lateral derecha, en modo, selecciona **EMR** (gestionado).
+ **En la barra lateral derecha, completa los formularios de las pestañas Configuración y Detalles.** [Para obtener información sobre los campos de estas pestañas, consulte sagemaker.workflow.fail\$1step. EMRstep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.emr_step.EMRStep).
**Lanzamiento de un nuevo trabajo en un clúster de Amazon EMR en ejecución**
Para inicializar un nuevo trabajo en un clúster de Amazon EMR en ejecución, debe pasar el ID del clúster en forma de cadena al argumento `cluster_id` del `EMRStep`. El siguiente ejemplo demuestra este procedimiento.
```
from sagemaker.workflow.emr_step import EMRStep, EMRStepConfig
emr_config = EMRStepConfig(
jar="jar-location", # required, path to jar file used
args=["--verbose", "--force"], # optional list of arguments to pass to the jar
main_class="com.my.Main1", # optional main class, this can be omitted if jar above has a manifest
properties=[ # optional list of Java properties that are set when the step runs
{
"key": "mapred.tasktracker.map.tasks.maximum",
"value": "2"
},
{
"key": "mapreduce.map.sort.spill.percent",
"value": "0.90"
},
{
"key": "mapreduce.tasktracker.reduce.tasks.maximum",
"value": "5"
}
]
)
step_emr = EMRStep (
name="EMRSampleStep", # required
cluster_id="j-1ABCDEFG2HIJK", # include cluster_id to use a running cluster
step_config=emr_config, # required
display_name="My EMR Step",
description="Pipeline step to execute EMR job"
)
```
Para ver un ejemplo de cuaderno que le guíe a través de un ejemplo completo, consulte [Pipelines EMR Step With Running EMR Cluster](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-running-emr-cluster.ipynb).
**Lanzamiento de un nuevo trabajo en un clúster de Amazon EMR nuevo**
Para inicializar un nuevo trabajo en un nuevo clúster que `EMRStep` cree para usted, proporcione la configuración de su clúster como diccionario. El diccionario debe tener la misma estructura que una [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html)solicitud. Sin embargo, no incluya los siguientes campos en la configuración del clúster:
+ [`Name`]
+ [`Steps`]
+ [`AutoTerminationPolicy`]
+ [`Instances`][`KeepJobFlowAliveWhenNoSteps`]
+ [`Instances`][`TerminationProtected`]
Todos los demás argumentos `RunJobFlow` están disponibles para su uso en la configuración del clúster. Para obtener más información sobre la sintaxis de la solicitud, consulte [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html).
El siguiente ejemplo pasa una configuración de clúster a una definición de paso EMR. Esto solicita al paso que inicialice un nuevo trabajo en un nuevo clúster de EMR. La configuración del clúster de EMR de este ejemplo incluye especificaciones para los nodos del clúster de EMR principales y básicos. Para obtener más información sobre los tipos de nodos de Amazon EMR, consulte [Descripción de los tipos de nodos: principales, básicos y de tarea](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html).
```
from sagemaker.workflow.emr_step import EMRStep, EMRStepConfig
emr_step_config = EMRStepConfig(
jar="jar-location", # required, path to jar file used
args=["--verbose", "--force"], # optional list of arguments to pass to the jar
main_class="com.my.Main1", # optional main class, this can be omitted if jar above has a manifest
properties=[ # optional list of Java properties that are set when the step runs
{
"key": "mapred.tasktracker.map.tasks.maximum",
"value": "2"
},
{
"key": "mapreduce.map.sort.spill.percent",
"value": "0.90"
},
{
"key": "mapreduce.tasktracker.reduce.tasks.maximum",
"value": "5"
}
]
)
# include your cluster configuration as a dictionary
emr_cluster_config = {
"Applications": [
{
"Name": "Spark",
}
],
"Instances":{
"InstanceGroups":[
{
"InstanceRole": "MASTER",
"InstanceCount": 1,
"InstanceType": "m5.2xlarge"
},
{
"InstanceRole": "CORE",
"InstanceCount": 2,
"InstanceType": "m5.2xlarge"
}
]
},
"BootstrapActions":[],
"ReleaseLabel": "emr-6.6.0",
"JobFlowRole": "job-flow-role",
"ServiceRole": "service-role"
}
emr_step = EMRStep(
name="emr-step",
cluster_id=None,
display_name="emr_step",
description="MyEMRStepDescription",
step_config=emr_step_config,
cluster_config=emr_cluster_config
)
```
Para ver un ejemplo de cuaderno que le guie a través de un ejemplo completo, consulte [Pipelines EMR Step With Cluster Lifecycle Management](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-cluster-lifecycle-management.ipynb).
## Paso EMR sin servidor
Para añadir un paso sin servidor de EMR a su canalización, haga lo siguiente:
+ Abre la consola de Studio siguiendo las instrucciones de [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ En el panel de navegación izquierdo, seleccione **Canalizaciones**.
+ Seleccione **Crear**.
+ Seleccione **En blanco**.
+ En la barra lateral izquierda, elija **Procesar datos** y arrástrelos al lienzo.
+ En el lienzo, elija el paso **Procesar datos** que ha añadido.
+ En la barra lateral derecha, en modo, selecciona **EMR** (sin servidor).
+ **En la barra lateral derecha, completa los formularios de las pestañas Configuración y Detalles.**
## Paso Trabajo de cuaderno
Utilice `NotebookJobStep` a para ejecutar su SageMaker Notebook Job de forma no interactiva como un paso de proceso. Si creas tu canalización en la drag-and-drop interfaz de usuario de Pipelines, úsala [paso de ejecución del código](#step-type-executecode) para ejecutar tu cuaderno. Para obtener más información sobre SageMaker Notebook Jobs, consulte[SageMaker Trabajos de cuaderno](notebook-auto-run.md).
Un `NotebookJobStep` requiere como mínimo un cuaderno de entrada, el URI de la imagen y el nombre del kernel. Para obtener más información sobre los requisitos de los pasos de Notebook Job y otros parámetros que puede configurar para personalizar su paso, consulte [sagemaker.workflow.steps. NotebookJobStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.notebook_job_step.NotebookJobStep).
En el siguiente ejemplo, se utilizan los argumentos mínimos para definir un `NotebookJobStep`.
```
from sagemaker.workflow.notebook_job_step import NotebookJobStep
notebook_job_step = NotebookJobStep(
input_notebook=input_notebook,
image_uri=image_uri,
kernel_name=kernel_name
)
```
El paso de la `NotebookJobStep` canalización se considera un trabajo de SageMaker cuaderno. Como resultado, realice un seguimiento del estado de ejecución en el panel de trabajos del cuaderno de la IU de Studio Classic incluyendo etiquetas específicas con el argumento `tags`. Para obtener más información acerca de las etiquetas que se deben incluir, consulte [Consulte los trabajos de cuaderno en el panel de la interfaz de usuario de Studio](create-notebook-auto-run-sdk.md#create-notebook-auto-run-dash).
Además, si programa el trabajo del bloc de notas con el SDK de SageMaker Python, solo podrá especificar determinadas imágenes para ejecutar el trabajo del bloc de notas. Para obtener más información, consulte [Restricciones de imagen para trabajos de cuadernos del SDK de Python para SageMaker IA](notebook-auto-run-constraints.md#notebook-auto-run-constraints-image-sdk).
## Paso Error
Utilice un paso de error para detener una ejecución de Amazon SageMaker Pipelines cuando no se alcance la condición o el estado deseados. El paso Error también le permite introducir un mensaje de error personalizado en el que se indique la causa del error de la ejecución de la canalización.
**nota**
Cuando un paso Error y otros pasos de la canalización se ejecutan al mismo tiempo, la canalización no finaliza hasta que todos los pasos simultáneos se hayan completado.
### Limitaciones del uso del paso Error
+ No puede añadir un paso Error a la lista `DependsOn` de otros pasos. Para obtener más información, consulte [Dependencia personalizada entre pasos](build-and-manage-steps.md#build-and-manage-custom-dependency).
+ Otros pasos no pueden hacer referencia al paso Error. Es *siempre* el último paso de la ejecución de una canalización.
+ No se puede volver a intentar ejecutar una canalización que termine con un paso Error.
Puede crear el mensaje del paso Error en forma de cadena de texto estático. Como alternativa, también puede utilizar [Parámetros de canalización](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-parameters.html), una operación de [unión](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html?highlight=Join#sagemaker.workflow.functions.Join) u otras [propiedades del paso](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#build-and-manage-properties) para crear un mensaje de error más informativo si usa el SDK.
------
#### [ Pipeline Designer ]
Para añadir un paso Error a su canalización, haga lo siguiente:
1. Abra la consola de Studio siguiendo las instrucciones de [Lanza Amazon SageMaker Studio](studio-updated-launch.md).
1. En el panel de navegación izquierdo, seleccione **Canalizaciones**.
1. Seleccione **Crear**.
1. Seleccione **En blanco**.
1. En la barra lateral izquierda, elija **Error** y arrástrelo al lienzo.
1. En el lienzo, elija el paso **Error** que ha añadido.
1. En la barra lateral derecha, complete los formularios de las pestañas **Configuración** y **Detalles**. Para obtener información sobre los campos de estas pestañas, consulte [sagemaker.workflow.fail\$1step. FailStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.fail_step.FailStep).
1. Si el lienzo incluye algún paso que preceda inmediatamente al paso **Error** que ha añadido, haga clic y arrastre el cursor desde el paso hasta el paso **Error** para crear un borde.
1. Si el lienzo incluye algún paso que sigue inmediatamente al paso **Error** que ha añadido, haga clic y arrastre el cursor desde el paso **Error** hasta el paso para crear un borde.
------
#### [ SageMaker Python SDK ]
**Example**
El siguiente fragmento de código de ejemplo utiliza un `FailStep` con un `ErrorMessage` configurado con parámetros de canalización y una operación `Join`.
```
from sagemaker.workflow.fail_step import FailStep
from sagemaker.workflow.functions import Join
from sagemaker.workflow.parameters import ParameterInteger
mse_threshold_param = ParameterInteger(name="MseThreshold", default_value=5)
step_fail = FailStep(
name="AbaloneMSEFail",
error_message=Join(
on=" ", values=["Execution failed due to MSE >", mse_threshold_param]
),
)
```
------
# Añadir integración
MLflow la integración le permite utilizarla MLflow con Pipelines para seleccionar un servidor de seguimiento o una aplicación sin servidor, elegir un experimento y registrar las métricas.
## Conceptos clave
**Creación de aplicaciones por defecto**: se creará una MLflow aplicación por defecto al entrar en el editor visual de Pipeline.
**Panel de integraciones**: incluye MLflow un nuevo panel de integraciones que puedes seleccionar y configurar.
**Actualizar la aplicación y el experimento**: la opción de anular la aplicación y el experimento seleccionados durante la ejecución del proceso.
## Funcionamiento
+ Ve al editor **visual Pipeline**
+ Selecciona **Integración** en la barra de herramientas
+ Haga clic en **MLflow**.
+ Configura la MLflow aplicación y experimenta
## Capturas de pantalla de ejemplo
Panel lateral de integraciones
![\[La descripción de las tareas pendientes.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/screenshot-pipeline-1.png)
MLflow configuración
![\[La descripción de las tareas pendientes.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/screenshot-pipeline-2.png)
Cómo anular el experimento durante la ejecución de la canalización
![\[La descripción de las tareas pendientes.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/screenshot-pipeline-3.png)
## Propiedades de paso
El atributo `properties` se utiliza para añadir dependencias de datos entre los pasos de la canalización. Las canalizaciones utilizan estas dependencias de datos para construir el DAG a partir de la definición de la canalización. Se puede hacer referencia a estas propiedades como valores de marcador de posición y se resuelven en el tiempo de ejecución.
El `properties` atributo de un paso de Pipelines coincide con el objeto devuelto por una `Describe` llamada para el tipo de trabajo de SageMaker IA correspondiente. Para cada tipo de trabajo, la llamada `Describe` devuelve el siguiente objeto de respuesta:
+ `ProcessingStep` – [DescribeProcessingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeProcessingJob.html)
+ `TrainingStep` – [DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)
+ `TransformStep` – [DescribeTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTransformJob.html)
Para comprobar qué propiedades son recomendables para cada tipo de paso durante la creación de una dependencia de datos, consulte Dependencia de *[datos: referencia de propiedades](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* en el SDK de Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
## Paralelismo de paso
Cuando un paso no depende de ningún otro paso, se ejecuta inmediatamente después de la ejecución de la canalización. Sin embargo, si se ejecutan demasiados pasos de canalización en paralelo se podrían agotar rápidamente los recursos disponibles. Controle el número de pasos simultáneos para la ejecución de una canalización con `ParallelismConfiguration`.
En el siguiente ejemplo, se utiliza `ParallelismConfiguration` para establecer el límite de pasos simultáneos en cinco.
```
pipeline.create(
parallelism_config=ParallelismConfiguration(5),
)
```
## Dependencia de datos entre pasos
La estructura del DAG se define al especificar las relaciones de datos entre los pasos. Para crear dependencias de datos entre los pasos, transfiera las propiedades de un paso como entrada a otro paso de la canalización. El paso que recibe la entrada no se inicia hasta que termina de ejecutarse el paso que proporciona la entrada.
Una dependencia de datos utiliza la JsonPath notación en el siguiente formato. Este formato recorre el archivo de propiedades de JSON. Esto significa que puede añadir tantas ** instancias como necesite para alcanzar la propiedad anidada deseada en el archivo. [Para obtener más información sobre la JsonPath notación, consulta el JsonPath repositorio.](https://github.com/json-path/JsonPath)
```
.properties..
```
A continuación se muestra cómo especificar un bucket de Amazon S3 mediante la propiedad `ProcessingOutputConfig` de un paso de procesamiento.
```
step_process.properties.ProcessingOutputConfig.Outputs["train_data"].S3Output.S3Uri
```
Para crear la dependencia de datos, pase el bucket a un paso de entrenamiento de la siguiente manera.
```
from sagemaker.workflow.pipeline_context import PipelineSession
sklearn_train = SKLearn(..., sagemaker_session=PipelineSession())
step_train = TrainingStep(
name="CensusTrain",
step_args=sklearn_train.fit(inputs=TrainingInput(
s3_data=step_process.properties.ProcessingOutputConfig.Outputs[
"train_data"].S3Output.S3Uri
))
)
```
Para comprobar qué propiedades son recomendables para cada tipo de paso durante la creación de una dependencia de datos, consulte Dependencia de *[datos: referencia de propiedades](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* en el SDK de Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
## Dependencia personalizada entre pasos
Al especificar una dependencia de datos, Canalizaciones proporciona la conexión de los datos entre los pasos. Como alternativa, un paso puede acceder a los datos de un paso anterior sin utilizar directamente Canalizaciones. En este caso, puede crear una dependencia personalizada que indique a Canalizaciones que no inicie un paso hasta que haya terminado de ejecutarse otro paso. Para crear una dependencia personalizada, especifique el atributo `DependsOn` de un paso.
A modo de ejemplo, lo siguiente define un paso `C` que comienza solo después de que el paso `A` y el paso `B` terminen de ejecutarse.
```
{
'Steps': [
{'Name':'A', ...},
{'Name':'B', ...},
{'Name':'C', 'DependsOn': ['A', 'B']}
]
}
```
Canalizaciones lanza una excepción de validación si la dependencia crea una dependencia cíclica.
En el siguiente ejemplo, se crea un paso de entrenamiento que comienza cuando termina de ejecutarse un paso de procesamiento.
```
processing_step = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step])
```
El siguiente ejemplo crea un paso de entrenamiento que no comienza hasta que terminen de ejecutarse dos pasos de procesamiento diferentes.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step_1, processing_step_2])
```
A continuación, se proporciona una forma alternativa de crear la dependencia personalizada.
```
training_step.add_depends_on([processing_step_1])
training_step.add_depends_on([processing_step_2])
```
El siguiente ejemplo crea un paso de entrenamiento que recibe la entrada de un paso de procesamiento y espera a que termine de ejecutarse otro paso de procesamiento.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(
...,
inputs=TrainingInput(
s3_data=processing_step_1.properties.ProcessingOutputConfig.Outputs[
"train_data"
].S3Output.S3Uri
)
training_step.add_depends_on([processing_step_2])
```
En el ejemplo siguiente se muestra cómo recuperar una lista de cadenas de las dependencias personalizadas de un paso.
```
custom_dependencies = training_step.depends_on
```
## Imágenes personalizadas en un paso
Puede usar cualquiera de las [imágenes de SageMaker AI Deep Learning Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) disponibles al crear un paso en su proceso.
También puede utilizar su propio contenedor con pasos de canalización. Dado que no puede crear una imagen desde Studio Classic, deberá crearla mediante otro método antes de utilizarla con Canalizaciones.
Para usar su propio contenedor al crear los pasos de la canalización, incluya el URI de la imagen en la definición del estimador. Para obtener más información sobre cómo usar tu propio contenedor con SageMaker IA, consulta Cómo [usar contenedores Docker con SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers.html).
# Lift-and-shift Código Python con el decorador @step
El decorador `@step` es una característica que convierte el código de machine learning (ML) local en uno o más pasos de canalización. Puede escribir su función de ML como para cualquier proyecto de ML. Una vez probada localmente o como un trabajo de formación con el `@remote` decorador, puedes convertir la función en un paso de proceso de SageMaker IA añadiendo un `@step` decorador. A continuación, puede pasar la salida de la llamada a la función decorada con `@step` como un paso a Canalizaciones para crear y ejecutar una canalización. También puede encadenar una serie de funciones con el decorador `@step` para crear también una canalización de gráficos acíclicos dirigidos (DAG) de varios pasos.
La configuración para usar el decorador `@step` es la misma que la configuración para usar el decorador `@remote`. Puede consultar la documentación de las funciones remotas para obtener información sobre cómo [configurar el entorno](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator.html#train-remote-decorator-env) y [utilizar un archivo de configuración](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html) para establecer los valores predeterminados. Para obtener más información sobre el decorador `@step`, consulte [sagemaker.workflow.function\$1step.step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.step).
Para ver ejemplos de cuadernos que demuestran el uso del decorador `@step`, consulte [@step decorator sample notebooks](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-pipelines/step-decorator).
En las siguientes secciones, se explica cómo anotar el código de ML local con un decorador `@step`para crear un paso, crear y ejecutar una canalización utilizando el paso y personalizar la experiencia para su caso de uso.
**Topics**
+ [Creación de una canalización con funciones decoradas con `@step`](pipelines-step-decorator-create-pipeline.md)
+ [Ejecución de una canalización](pipelines-step-decorator-run-pipeline.md)
+ [Configuración de la canalización](pipelines-step-decorator-cfg-pipeline.md)
+ [Prácticas recomendadas](pipelines-step-decorator-best.md)
+ [Limitaciones](pipelines-step-decorator-limit.md)
# Creación de una canalización con funciones decoradas con `@step`
Puede crear una canalización convirtiendo las funciones de Python en pasos de canalización mediante el decorador `@step`, creando dependencias entre esas funciones para crear un gráfico de canalización (o gráfico acíclico dirigido [DAG]) y pasando los nodos de hoja de ese gráfico como una lista de pasos a la canalización. En las siguientes secciones, se explica este procedimiento en detalle con ejemplos.
**Topics**
+ [Conversión de una función en un paso](#pipelines-step-decorator-run-pipeline-convert)
+ [Creación de dependencias entre los pasos](#pipelines-step-decorator-run-pipeline-link)
+ [Uso de `ConditionStep` con pasos decorados con `@step`](#pipelines-step-decorator-condition)
+ [Definición de una canalización utilizando la salida `DelayedReturn` de los pasos](#pipelines-step-define-delayed)
+ [Creación de una canalización](#pipelines-step-decorator-pipeline-create)
## Conversión de una función en un paso
Para crear un paso con el decorador `@step`, anote la función con `@step`. En el siguiente ejemplo, se muestra una función decorada con `@step` que preprocesa los datos.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
step_process_result = preprocess(raw_data)
```
Cuando invocas una función `@step` decorada con símbolos, la SageMaker IA devuelve una `DelayedReturn` instancia en lugar de ejecutar la función. Una instancia de `DelayedReturn` es un proxy de la devolución real de esa función. La instancia de `DelayedReturn` se puede pasar a otra función como argumento o directamente a una instancia de canalización como paso. [Para obtener información sobre la `DelayedReturn` clase, consulta sagemaker.workflow.function\$1step. DelayedReturn](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.DelayedReturn).
## Creación de dependencias entre los pasos
Al crear una dependencia entre dos pasos, se crea una conexión entre los pasos del gráfico de canalización. En las siguientes secciones, se presentan varias formas de crear una dependencia entre los pasos de la canalización.
### Dependencias de datos a través de argumentos de entrada
Al pasar la salida `DelayedReturn` de una función como entrada a otra función, se crea automáticamente una dependencia de datos en el DAG de la canalización. En el siguiente ejemplo, al pasar la salida `DelayedReturn` de la función `preprocess` a la función `train`, se crea una dependencia entre `preprocess` y `train`.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
@step
def train(training_data):
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train(step_process_result)
```
El ejemplo anterior define una función de entrenamiento que está decorada con `@step`. Cuando se invoca esta función, recibe como entrada la salida `DelayedReturn` del paso de la canalización de preprocesamiento. Al invocar la función de entrenamiento, se devuelve otra instancia de `DelayedReturn`. Esta instancia contiene la información sobre todos los pasos anteriores definidos en esa función (es decir, el paso `preprocess` de este ejemplo) que forman el DAG de la canalización.
En el ejemplo anterior, la función `preprocess` devuelve un valor único. Para ver tipos de devoluciones más complejas, como listas o tuplas, consulte [Limitaciones](pipelines-step-decorator-limit.md).
### Definición de dependencias personalizadas
En el ejemplo anterior, la función `train` recibió la salida `DelayedReturn` de `preprocess` y creó una dependencia. Si desea definir la dependencia de forma explícita sin pasar la salida del paso anterior, utilice la función `add_depends_on` con el paso. Puede usar la función `get_step()` para recuperar el paso subyacente de su instancia de `DelayedReturn` y, a continuación, llamar a `add_depends_on`\$1on con la dependencia como entrada. Para ver la definición de la función `get_step()`, consulte [sagemaker.workflow.step\$1outputs.get\$1step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_outputs.get_step). El siguiente ejemplo muestra cómo crear una dependencia entre `preprocess` y `train` usando `get_step()` y `add_depends_on()`.
```
from sagemaker.workflow.step_outputs import get_step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
processed_data = ..
return s3.upload(processed_data)
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train()
get_step(step_train_result).add_depends_on([step_process_result])
```
### Transferencia de datos desde y hacia una función decorada con `@step` para un paso de canalización tradicional
Puede crear una canalización que incluya un paso decorado con `@step` y un paso de canalización tradicional y pasar datos entre ellos. Por ejemplo, puede utilizar `ProcessingStep` para procesar los datos y pasar su resultado a la función de entrenamiento decorada con `@step`. En el siguiente ejemplo, un paso de entrenamiento decorado con `@step` hace referencia al resultado de un paso de procesamiento.
```
# Define processing step
from sagemaker.sklearn.processing import SKLearnProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
sklearn_processor = SKLearnProcessor(
framework_version='1.2-1',
role='arn:aws:iam::123456789012:role/SagemakerExecutionRole',
instance_type='ml.m5.large',
instance_count='1',
)
inputs = [
ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
]
outputs = [
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
]
process_step = ProcessingStep(
name="MyProcessStep",
step_args=sklearn_processor.run(inputs=inputs, outputs=outputs,code='preprocessing.py'),
)
```
```
# Define a @step-decorated train step which references the
# output of a processing step
@step
def train(train_data_path, test_data_path):
...
return trained_model
step_train_result = train(
process_step.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
process_step.properties.ProcessingOutputConfig.Outputs["test"].S3Output.S3Uri,
)
```
## Uso de `ConditionStep` con pasos decorados con `@step`
Canalizaciones admite una clase `ConditionStep` que evalúa los resultados de los pasos anteriores para decidir qué medidas tomar en la canalización. También puede utilizar `ConditionStep` con un paso decorado con `@step`. Para usar la salida de cualquier paso decorado con `@step` con `ConditionStep`, introduzca la salida de ese paso como argumento para `ConditionStep`. En el siguiente ejemplo, el paso de condición recibe el resultado del paso de evaluación del modelo decorado con `@step`.
```
# Define steps
@step(name="evaluate")
def evaluate_model():
# code to evaluate the model
return {
"rmse":rmse_value
}
@step(name="register")
def register_model():
# code to register the model
...
```
```
# Define ConditionStep
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.conditions import ConditionGreaterThanOrEqualTo
from sagemaker.workflow.fail_step import FailStep
conditionally_register = ConditionStep(
name="conditional_register",
conditions=[
ConditionGreaterThanOrEqualTo(
# Output of the evaluate step must be json serializable
left=evaluate_model()["rmse"], #
right=5,
)
],
if_steps=[FailStep(name="Fail", error_message="Model performance is not good enough")],
else_steps=[register_model()],
)
```
## Definición de una canalización utilizando la salida `DelayedReturn` de los pasos
La canalización se define de la misma manera independientemente de si se utiliza o no un decorador `@step`. Cuando pasa una instancia de `DelayedReturn` a su canalización, no es necesario pasar una lista completa de pasos para crear la canalización. El SDK deduce automáticamente los pasos anteriores en función de las dependencias que defina. Todos los pasos anteriores de los objetos `Step` que ha pasado a la canalización o a los objetos `DelayedReturn` se incluyen en el gráfico de la canalización. En el siguiente ejemplo, la canalización recibe el objeto `DelayedReturn` de la función `train`. SageMaker La IA añade el `preprocess` paso, como paso anterior`train`, al gráfico de canalización.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=,
)
```
Si no hay datos o dependencias personalizadas entre los pasos y ejecuta varios pasos en paralelo, el gráfico de canalización tiene más de un nodo hoja. Pase todos estos nodos de hoja en una lista al argumento `steps` de la definición de la canalización, tal y como se muestra en el siguiente ejemplo:
```
@step
def process1():
...
return data
@step
def process2():
...
return data
step_process1_result = process1()
step_process2_result = process2()
pipeline = Pipeline(
name="",
steps=[step_process1_result, step_process2_result],
sagemaker_session=sagemaker-session,
)
```
Cuando se ejecuta la canalización, ambos pasos se ejecutan en paralelo.
Solo se pasan los nodos de hoja del gráfico a la canalización, ya que los nodos de hoja contienen información sobre todos los pasos anteriores definidos mediante dependencias de datos o personalizadas. Al compilar la canalización, la SageMaker IA también deduce todos los pasos subsiguientes que forman el gráfico de la canalización y añade cada uno de ellos como un paso independiente a la canalización.
## Creación de una canalización
Cree una canalización mediante una llamada a `pipeline.create()`, tal y como se muestra en el siguiente fragmento. Para obtener más información sobre `create()`, consulte [sagemaker.workflow.pipeline.Pipeline.create](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.create).
```
role = "pipeline-role"
pipeline.create(role)
```
Cuando llamas`pipeline.create()`, la SageMaker IA compila todos los pasos definidos como parte de la instancia de canalización. SageMaker La IA carga la función serializada, los argumentos y todos los demás artefactos relacionados con los pasos en Amazon S3.
Los datos residen en el bucket de S3 de acuerdo con la siguiente estructura:
```
s3_root_uri/
pipeline_name/
sm_rf_user_ws/
workspace.zip # archive of the current working directory (workdir)
step_name/
timestamp/
arguments/ # serialized function arguments
function/ # serialized function
pre_train_dependencies/ # any dependencies and pre_execution scripts provided for the step
execution_id/
step_name/
results # returned output from the serialized function including the model
```
`s3_root_uri`se define en el archivo de configuración de SageMaker AI y se aplica a toda la canalización. Si no está definido, se utiliza el depósito de SageMaker IA predeterminado.
**nota**
Cada vez que la SageMaker IA compila una canalización, SageMaker guarda las funciones, los argumentos y las dependencias serializados de los pasos en una carpeta con la fecha y hora actuales. Esto ocurre cada vez que ejecuta `pipeline.create()`, `pipeline.update()`, `pipeline.upsert()` o `pipeline.definition()`.
# Ejecución de una canalización
En la siguiente página se describe cómo ejecutar una canalización con Amazon SageMaker Pipelines, ya sea con recursos de SageMaker IA o de forma local.
Inicie una nueva ejecución de canalización con la `pipeline.start()` función como lo haría con una canalización de SageMaker IA tradicional. Para obtener más información sobre la función `start()`, consulte [sagemaker.workflow.pipeline.Pipeline.start](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.start).
**nota**
Un paso definido con el decorador `@step` funciona como un trabajo de entrenamiento. Por tanto, debe tener en cuenta los siguientes límites:
Límites de instancias y límites de trabajos de entrenamiento en sus cuentas. Actualice sus límites en consecuencia para evitar problemas de limitación o límites de recursos.
El costo económico asociado a cada ejecución de un paso de entrenamiento de la canalización. Para obtener más información, consulta los [ SageMaker precios de Amazon](https://aws.amazon.com/sagemaker/pricing/).
## Recuperación de los resultados de una canalización ejecutada localmente
Para ver el resultado de cualquier paso de la ejecución de una canalización, use [execution.result()](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline._PipelineExecution.result ), como se muestra en el siguiente fragmento:
```
execution = pipeline.start()
execution.result(step_name="train")
```
**nota**
Canalizaciones no es compatible con `execution.result()` en el modo local.
Solo puede recuperar los resultados de un paso cada vez. Si el nombre del paso lo generó la SageMaker IA, puedes recuperarlo llamando de la `list_steps` siguiente manera:
```
execution.list_step()
```
## Ejecución de una canalización de forma local
Puede ejecutar una canalización con pasos decorados con `@step` localmente, como lo haría con los pasos de una canalización tradicional. Para obtener más información sobre la ejecución de canalizaciones en modo local, consulte [Ejecución de canalizaciones en modo local](pipelines-local-mode.md). Para usar el modo local, proporciona una `LocalPipelineSession` en lugar de una `SageMakerSession` a su definición de canalización, tal y como se muestra en el siguiente ejemplo:
```
from sagemaker.workflow.function_step import step
from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.pipeline_context import LocalPipelineSession
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_train_result = train()
local_pipeline_session = LocalPipelineSession()
local_pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=local_pipeline_session # needed for local mode
)
local_pipeline.create(role_arn="role_arn")
# pipeline runs locally
execution = local_pipeline.start()
```
# Configuración de la canalización
Se recomienda utilizar el archivo de configuración de SageMaker AI para establecer los valores predeterminados de la canalización. Para obtener información sobre el archivo de configuración de SageMaker AI, consulte [Configuración y uso de valores predeterminados con el SDK de SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#configuring-and-using-defaults-with-the-sagemaker-python-sdk). Cualquier configuración que se añada al archivo de configuración se aplica a todos los pasos de la canalización. Si quiere anular las opciones de alguno de los pasos, proporcione nuevos valores en los argumentos del decorador `@step`. En el siguiente tema, se describe cómo configurar un archivo de configuración.
La configuración del decorador `@step` en el archivo de configuración es idéntica a la configuración del decorador `@remote`. Para configurar el ARN del rol de canalización y las etiquetas de canalización en el archivo de configuración, use la sección `Pipeline` que se muestra en el siguiente fragmento:
```
SchemaVersion: '1.0'
SageMaker:
Pipeline:
RoleArn: 'arn:aws:iam::555555555555:role/IMRole'
Tags:
- Key: 'tag_key'
Value: 'tag_value'
```
La mayoría de los valores predeterminados que se pueden establecer en el archivo de configuración también se pueden anular pasando nuevos valores al decorador `@step`. Por ejemplo, puede anular el tipo de instancia establecido en el archivo de configuración para el paso de preprocesamiento, tal y como se muestra en el ejemplo siguiente:
```
@step(instance_type="ml.m5.large")
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
```
Algunos argumentos no forman parte de la lista de parámetros del `@step` decorador; solo se pueden configurar para toda la canalización a través del archivo de configuración de SageMaker AI. Son los siguientes:
+ `sagemaker_session`(`sagemaker.session.Session`): La sesión de SageMaker IA subyacente en la que la SageMaker IA delega las llamadas de servicio. Si no se especifica, se crea una sesión con la siguiente configuración predeterminada:
```
SageMaker:
PythonSDK:
Modules:
Session:
DefaultS3Bucket: 'default_s3_bucket'
DefaultS3ObjectKeyPrefix: 'key_prefix'
```
+ `custom_file_filter` (`CustomFileFilter)`: un objeto `CustomFileFilter` que especifica los directorios y archivos locales que se van a incluir en el paso de canalización. Si no se especifica, este valor se establece de forma predeterminada en `None`. Para que `custom_file_filter` se aplique, debe establecer `IncludeLocalWorkdir` en `True`. El siguiente ejemplo muestra una configuración que ignora todos los archivos del cuaderno, así como los archivos y directorios denominados `data`.
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
IncludeLocalWorkDir: true
CustomFileFilter:
IgnoreNamePatterns: # files or directories to ignore
- "*.ipynb" # all notebook files
- "data" # folder or file named "data"
```
Para obtener más información sobre cómo utilizar `IncludeLocalWorkdir` con `CustomFileFilter`, consulte [Uso de código modular con el decorador @remote](train-remote-decorator-modular.md).
+ `s3_root_uri (str)`: la carpeta raíz de Amazon S3 en la que SageMaker AI carga los archivos de código y los datos. Si no se especifica, se utiliza el depósito de SageMaker IA predeterminado.
+ `s3_kms_key (str)`: clave utilizada para cifrar los datos de entrada y salida. Solo puedes configurar este argumento en el archivo de configuración de SageMaker AI y el argumento se aplica a todos los pasos definidos en la canalización. Si no se especifica, el valor se establece de forma predeterminada en `None`. Consulte el siguiente fragmento para ver un ejemplo de la configuración de claves KMS de S3:
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
S3KmsKeyId: 's3kmskeyid'
S3RootUri: 's3://amzn-s3-demo-bucket/my-project
```
# Prácticas recomendadas
En las secciones siguientes, se incluyen prácticas recomendadas para usar el decorador `@step` en los pasos de la canalización.
## Uso de grupos de calentamiento
Para agilizar las ejecuciones de las canalizaciones, utilice la funcionalidad de grupos de calentamiento que se proporciona para los trabajos de entrenamiento. Para activar la funcionalidad de grupos de calentamiento, proporcione el argumento `keep_alive_period_in_seconds` al decorador `@step`, tal y como se muestra en el siguiente fragmento:
```
@step(
keep_alive_period_in_seconds=900
)
```
Para obtener más información acerca de los grupos de calentamiento, consulte [SageMaker Piscinas calientes gestionadas por IA](train-warm-pools.md).
## Estructuración del directorio
Se recomienda utilizar módulos de código mientras se utiliza el decorador `@step`. Coloque el módulo `pipeline.py`, en el que invoca las funciones de pasos y se define la canalización, en la raíz del espacio de trabajo. La estructura recomendada se muestra de la siguiente manera:
```
.
├── config.yaml # the configuration file that define the infra settings
├── requirements.txt # dependencies
├── pipeline.py # invoke @step-decorated functions and define the pipeline here
├── steps/
| ├── processing.py
| ├── train.py
├── data/
├── test/
```
# Limitaciones
En las secciones siguientes, se describen las limitaciones que hay que tener en cuenta al utilizar el decorador `@step` en los pasos de canalización.
## Limitaciones de los argumentos de funciones
Al pasar un argumento de entrada a la función decorada con `@step`, se aplican las siguientes limitaciones:
+ Puede pasar los objetos `DelayedReturn`, `Properties` (de pasos de otros tipos) `Parameter` y `ExecutionVariable` a funciones decoradas con `@step` como argumentos. Sin embargo, las funciones decoradas con `@step` no admiten objetos `JsonGet` y `Join` como argumentos.
+ No se puede acceder directamente a una variable de canalización desde una función `@step`. El siguiente ejemplo produce un error:
```
param = ParameterInteger(name="", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ No puede anidar una variable de canalización en otro objeto y pasarlo a una función `@step`. El siguiente ejemplo produce un error:
```
param = ParameterInteger(name="", default_value=10)
@step
def func(arg):
print(arg)
func(arg=(param,)) # this raises a SerializationError because param is nested in a tuple
```
+ Como las entradas y salidas de una función están serializadas, existen restricciones en cuanto al tipo de datos que se puede transferir como entrada o salida desde una función. Consulte la sección *Serialización y deserialización de datos* de [Invocación de una función remota](train-remote-decorator-invocation.md) para obtener más información. Las mismas restricciones se aplican a las funciones decoradas con `@step`.
+ Ningún objeto que tenga un cliente boto se puede serializar, por lo que no se pueden pasar dichos objetos como entrada o salida desde una función decorada con `@step`. Por ejemplo, las clases de cliente del SDK de SageMaker Python`Estimator`, como`Predictor`, y, no se `Processor` pueden serializar.
## Importaciones de funciones
Debe importar las bibliotecas necesarias para el paso dentro más que fuera de la función. Si las importa a escala global, corre el riesgo de que se produzca un error de importación al serializar la función. Por ejemplo, `sklearn.pipeline.Pipeline` podría ser anulada por `sagemaker.workflow.pipeline.Pipeline`.
## Referencia a miembros secundarios del valor de devolución de la función
Si hace referencia a los miembros secundarios del valor de devolución de una función decorada con `@step`, se aplican las siguientes limitaciones:
+ Puede hacer referencia a los miembros secundarios con `[]` si el objeto `DelayedReturn` representa una tupla, una lista o un dictado, como se muestra en el siguiente ejemplo:
```
delayed_return[0]
delayed_return["a_key"]
delayed_return[1]["a_key"]
```
+ No se puede desempaquetar el resultado de una tupla o lista, porque no se puede conocer la longitud exacta de la tupla o lista subyacente al invocar la función. El siguiente ejemplo produce un error:
```
a, b, c = func() # this raises ValueError
```
+ No se puede iterar sobre un objeto `DelayedReturn`. El siguiente ejemplo da un error:
```
for item in func(): # this raises a NotImplementedError
```
+ No se puede hacer referencia a miembros secundarios arbitrarios con `.`. El siguiente ejemplo produce un error:
```
delayed_return.a_child # raises AttributeError
```
## Características de canalización existentes que no se admiten
No puede usar el decorador `@step` con las siguientes características de canalización:
+ [Almacenamiento en caché de pasos de canalización](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-caching.html)
+ [Archivos de propiedades](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html#build-and-manage-propertyfile-property)
# Transferencia de datos entre pasos
Al crear canalizaciones con Amazon SageMaker Pipelines, es posible que necesite pasar los datos de un paso al siguiente. Por ejemplo, es posible que desee utilizar los artefactos del modelo generados por un paso de entrenamiento como entrada para un paso de evaluación del modelo o implementación. Puede usar esta funcionalidad para crear pasos de canalización interdependientes y crear sus flujos de trabajo de ML.
Cuando necesite recuperar información de la salida de un paso de la canalización, puede usar `JsonGet`. `JsonGet` le ayuda a extraer información de Amazon S3 o de archivos de propiedades. En las siguientes secciones, se explican los métodos que puede utilizar para extraer la salida de los pasos con `JsonGet`.
## Transferencia de datos entre pasos con Amazon S3
Puede utilizar `JsonGet` en un `ConditionStep` para obtener la salida JSON directamente desde Amazon S3. El URI de Amazon S3 puede ser una función `Std:Join` que contiene cadenas primitivas, variables de ejecución de canalización o parámetros de canalización. El siguiente ejemplo muestra cómo puede utilizar `JsonGet` en un `ConditionStep`:
```
# Example json file in s3 bucket generated by a processing_step
{
"Output": [5, 10]
}
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name="",
s3_uri="",
json_path="Output[1]"
),
right=6.0
)
```
Si utiliza `JsonGet` con una ruta de Amazon S3 en el paso de condición, debe añadir explícitamente una dependencia entre el paso de condición y el paso que genera la salida de JSON. En el siguiente ejemplo, el paso de condición se crea con una dependencia en el paso de procesamiento:
```
cond_step = ConditionStep(
name="",
conditions=[cond_lte],
if_steps=[fail_step],
else_steps=[register_model_step],
depends_on=[processing_step],
)
```
## Transferencia de datos entre pasos con archivos de propiedades
Use los archivos de propiedades para almacenar la información de la salida de un paso de procesamiento. Resulta particularmente útil cuando se analizan los resultados de un paso de procesamiento para decidir cómo se debe ejecutar un paso condicional. La `JsonGet` función procesa un archivo de propiedades y le permite utilizar la JsonPath notación para consultar el archivo JSON de propiedades. Para obtener más información sobre la JsonPath notación, consulta el [JsonPath repositorio](https://github.com/json-path/JsonPath).
Para almacenar un archivo de propiedades para utilizarlo más adelante, primero debe crear una instancia `PropertyFile` con el siguiente formato. El parámetro `path` es el nombre del archivo JSON en el que se guarda el archivo de propiedades. Cualquier `output_name` debe coincidir con el `output_name` de la `ProcessingOutput` que defina en el paso de procesamiento. Esto permite que el archivo de propiedades capture la `ProcessingOutput` en el paso.
```
from sagemaker.workflow.properties import PropertyFile
= PropertyFile(
name="",
output_name="",
path=""
)
```
Cuando cree la `ProcessingStep` instancia, añada el `property_files` parámetro para enumerar todos los archivos de parámetros que el servicio Amazon SageMaker Pipelines debe indexar. De este modo, se guarda el archivo de propiedades para utilizarse más adelante.
```
property_files=[]
```
Para usar el archivo de propiedades en un paso de condición, agregue el `property_file` a la condición que va a pasar al paso de condición, como se muestra en el siguiente ejemplo, para consultar el archivo JSON de la propiedad deseada mediante el parámetro `json_path`.
```
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=,
json_path="mse"
),
right=6.0
)
```
Para ver ejemplos más detallados, consulte *[Property File](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#property-file)* en el [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Almacenamiento en caché de pasos de canalización
En Amazon SageMaker Pipelines, puede utilizar el almacenamiento en caché por pasos para ahorrar tiempo y recursos al volver a ejecutar canalizaciones. El almacenamiento en caché de pasos reutiliza el resultado de una ejecución correcta anterior de un paso (en lugar de volver a procesarlo) cuando el paso tiene la misma configuración y las mismas entradas. Esto ayuda a conseguir resultados uniformes en todas las nuevas ejecuciones de la canalización con parámetros idénticos. En el siguiente tema, se muestra cómo configurar y activar el almacenamiento en caché de pasos para las canalizaciones.
Al utilizar el almacenamiento en caché de firmas de pasos, Canalizaciones intenta buscar una ejecución anterior del paso de canalización actual con los mismos valores para determinados atributos. Si la encuentra, Canalizaciones propaga las salidas de la ejecución anterior en lugar de volver a procesar el paso. Los atributos marcados son específicos del tipo de paso y se enumeran en [Atributos clave de caché predeterminados por tipo de paso de la canalización](pipelines-default-keys.md).
Debe elegir utilizar el almacenamiento en caché de pasos; está desactivado de forma predeterminada. Al activar el almacenamiento en caché de pasos, también debe definir un tiempo de espera. Este tiempo de espera define la antigüedad que puede tener una ejecución anterior para que aún pueda reutilizarse.
El almacenamiento en caché de pasos solo considera las ejecuciones correctas; nunca reutiliza las ejecuciones que produjeron un error. Cuando hay varias ejecuciones correctas dentro del período de tiempo de espera, Canalizaciones utiliza el resultado de la ejecución correcta más reciente. Si ninguna ejecución correcta coincide en el período de tiempo de espera, Canalizaciones vuelve a ejecutar el paso. Si el ejecutor encuentra una ejecución anterior que cumple los criterios pero que aún está en curso, ambos pasos seguirán ejecutándose y actualizarán la caché si se realizan correctamente.
El almacenamiento en caché de pasos solo se aplica a canalizaciones individuales, por lo que no puede reutilizar un paso de otra canalización aunque la firma de un paso coincida.
El almacenamiento en caché de pasos está disponible para los siguientes tipos de pasos:
+ [Procesando](build-and-manage-steps-types.md#step-type-processing)
+ [Formación](build-and-manage-steps-types.md#step-type-training)
+ [Ajuste](build-and-manage-steps-types.md#step-type-tuning)
+ [AutoML](build-and-manage-steps-types.md#step-type-automl)
+ [Transformar](build-and-manage-steps-types.md#step-type-transform)
+ [`ClarifyCheck`](build-and-manage-steps-types.md#step-type-clarify-check)
+ [`QualityCheck`](build-and-manage-steps-types.md#step-type-quality-check)
+ [EMR](build-and-manage-steps-types.md#step-type-emr)
**Topics**
+ [Activación del almacenamiento en caché de pasos](pipelines-caching-enabling.md)
+ [Desactivación del almacenamiento en caché de pasos](pipelines-caching-disabling.md)
+ [Atributos clave de caché predeterminados por tipo de paso de la canalización](pipelines-default-keys.md)
+ [Control de acceso a los datos en caché](pipelines-access-control.md)
# Activación del almacenamiento en caché de pasos
Para activar el almacenamiento en caché de pasos, debe añadir una propiedad `CacheConfig` a la definición del paso. Las propiedades `CacheConfig` utilizan el siguiente formato en el archivo de definición de la canalización:
```
{
"CacheConfig": {
"Enabled": false,
"ExpireAfter": "