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.
# 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).