Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Fasi delle pipeline
Le pipeline sono costituite da fasi. Queste fasi definiscono le operazioni intraprese dalla pipeline e le relazioni tra le fasi utilizzando le proprietà. La pagina seguente descrive i tipi di fasi, le relative proprietà e le relazioni tra di esse.
**Topics**
+ [Aggiunta di una fase](build-and-manage-steps-types.md)
+ [Aggiungi integrazione](build-and-manage-steps-integration.md)
+ [Proprietà della fase](#build-and-manage-properties)
+ [Parallelizzazione delle fasi](#build-and-manage-parallelism)
+ [Dipendenza dei dati tra le fasi](#build-and-manage-data-dependency)
+ [Dipendenza personalizzata tra le fasi](#build-and-manage-custom-dependency)
+ [Immagini personalizzate in una fase](#build-and-manage-images)
# Aggiunta di una fase
Di seguito vengono descritti i requisiti di ogni tipo di fase e viene fornita un’implementazione di esempio della fase, nonché informazioni su come aggiungere la fase a una pipeline. Non si tratta di implementazioni funzionali perché non forniscono le risorse e gli input necessari. Per un tutorial che implementa queste fasi, consulta [Azioni di Pipelines](pipelines-build.md).
**Nota**
Puoi anche creare una fase dal codice di machine learning locale convertendola in una fase Pipelines con il decoratore `@step`. Per ulteriori informazioni, consulta [Decoratore @step](#step-type-custom).
Amazon SageMaker Pipelines supporta i seguenti tipi di passaggi:
+ [Esecuzione di codice](#step-type-executecode)
[Processing](#step-type-processing)
+ [Addestramento](#step-type-training)
+ [Ottimizzazione](#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)
+ [Trasformazione](#step-type-transform)
+ [Condizione](#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)
+ [Processo del notebook](#step-type-notebook-job)
+ [Fail](#step-type-fail)
## Decoratore @step
Se desideri orchestrare un processo di machine learning personalizzato che sfrutti funzionalità di SageMaker intelligenza artificiale avanzate o altri AWS servizi nell'interfaccia utente di drag-and-drop Pipelines, utilizza il. [Fase Esecuzione di codice](#step-type-executecode)
Puoi creare una fase dal codice di machine learning locale utilizzando il decoratore `@step`. Dopo aver testato il codice, puoi convertire la funzione in una fase di pipeline SageMaker AI annotandola con il decoratore. `@step` Pipelines crea ed esegue una pipeline quando passi alla pipeline l’output della funzione decorata con `@step` come fase. Puoi anche creare una pipeline DAG in più fasi che includa una o più funzioni `@step` decorate oltre ai tradizionali passaggi della pipeline AI. SageMaker Per ulteriori dettagli su come creare una fase con il decoratore `@step`, consulta [Lift-and-shift Codice Python con il decoratore @step](pipelines-step-decorator.md).
## Fase Esecuzione di codice
Nell' drag-and-dropinterfaccia utente di Pipelines, puoi utilizzare un passaggio di codice Execute per **eseguire il tuo codice** come passaggio della pipeline. Puoi caricare una funzione, uno script o un notebook Python da eseguire come parte della tua pipeline. È necessario utilizzare questo passaggio se si desidera orchestrare un processo di machine learning personalizzato che sfrutti funzionalità di SageMaker intelligenza artificiale avanzate o altri servizi. AWS
La fase **Execute Code** carica i file nel bucket Amazon S3 predefinito per SageMaker Amazon AI. Questo bucket potrebbe non disporre del set di autorizzazioni Condivisione delle risorse multiorigine (CORS) richiesto. Per ulteriori informazioni sulla configurazione delle autorizzazioni CORS, consulta [Requisito CORS per i dati delle immagini di input](sms-cors-update.md).
La fase **Execute Code** utilizza un processo di SageMaker formazione Amazon per eseguire il codice. Verifica che il tuo ruolo IAM disponga delle autorizzazioni API `sagemaker:DescribeTrainingJob` e `sagemaker:CreateTrainingJob`. Per ulteriori informazioni su tutte le autorizzazioni richieste per Amazon SageMaker AI e su come configurarle, consulta[Autorizzazioni API Amazon SageMaker AI: riferimento ad azioni, autorizzazioni e risorse](api-permissions-reference.md).
Per aggiungere una fase Esecuzione di codice a una pipeline utilizzando Pipeline Designer, procedi come descritto di seguito:
1. Apri la console Amazon SageMaker Studio seguendo le istruzioni riportate in[Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Scegli **Vuoto**.
1. Nella barra laterale sinistra, scegli **Esecuzione di codice** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Esecuzione di codice** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**.
1. Puoi caricare un singolo file da eseguire o caricare una cartella compressa che contiene più artefatti.
1. Per i caricamenti di singoli file, puoi fornire parametri facoltativi per notebook, funzioni Python o script.
1. Quando fornisci funzioni Python, devi specificare un gestore in formato `file.py:`.
1. Per i caricamenti di cartelle compresse, è necessario fornire i percorsi relativi per il codice e, facoltativamente, i percorsi per un file `requirements.txt` o uno script di inizializzazione all’interno della cartella compressa.
1. Se il canvas include una fase immediatamente precedente alla fase **Esecuzione di codice** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Esecuzione di codice** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Esecuzione di codice** che hai aggiunto, fai clic e trascina il cursore dalla fase **Esecuzione di codice** all’altra fase per creare un arco. Puoi fare riferimento agli output delle fasi **Esecuzione di codice** per le funzioni Python.
## Fase di elaborazione
Utilizza una fase di elaborazione per creare un processo di elaborazione per l'elaborazione dei dati. Per ulteriori informazioni sull'elaborazione dei processi, consulta [Elaborazione di dati e valutazione di modelli](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html).
------
#### [ Pipeline Designer ]
Per aggiungere una fase di elaborazione a una pipeline con Pipeline Designer, procedi come descritto di seguito:
1. Apri la console Amazon SageMaker Studio seguendo le istruzioni riportate in[Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Nella barra laterale sinistra, scegli **Elaborazione di dati** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Elaborazione di dati** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**. Per informazioni sui campi di queste schede, consulta [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep).
1. Se il canvas include una fase immediatamente precedente alla fase **Elaborazione di dati** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Elaborazione di dati** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Elaborazione di dati** che hai aggiunto, fai clic e trascina il cursore dalla fase **Elaborazione di dati** all’altra fase per creare un arco.
------
#### [ SageMaker Python SDK ]
Una fase di elaborazione richiede un processore, uno script Python che definisce il codice di elaborazione, gli output per l'elaborazione e gli argomenti del processo. L'esempio seguente mostra come creare una definizione di `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")
)
```
**Passaggio di parametri di runtime**
L'esempio seguente mostra come passare i parametri di runtime da un PySpark processore 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,
)
```
Per ulteriori informazioni sui requisiti delle fasi di elaborazione, consulta [sagemaker.workflow.steps. ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)documentazione. Per un esempio approfondito, consulta il notebook di esempio [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). La sezione *Define a Processing Step for Feature Engineering* include ulteriori informazioni.
------
## Fase di addestramento
Si utilizza una fase di addestramento per creare un processo di addestramento per addestrare un modello. Per ulteriori informazioni sui lavori di formazione, consulta [Train a Model with Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
Una fase di addestramento richiede uno strumento di valutazione e input di dati di addestramento e convalida.
------
#### [ Pipeline Designer ]
Per aggiungere una fase di addestramento a una pipeline utilizzando Pipeline Designer, procedi come descritto di seguito:
1. Apri la console Amazon SageMaker Studio seguendo le istruzioni riportate in[Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Scegli **Vuoto**.
1. Nella barra laterale sinistra, scegli **Addestramento di un modello** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Addestramento di un modello** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**. Per informazioni sui campi di queste schede, consulta [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep).
1. Se il canvas include una fase immediatamente precedente alla fase **Addestramento di un modello** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Addestramento di un modello** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Addestramento di un modello** che hai aggiunto, fai clic e trascina il cursore dalla fase **Addestramento di un modello** all’altra fase per creare un arco.
------
#### [ SageMaker Python SDK ]
L'esempio seguente mostra come creare una definizione di `TrainingStep`. Per ulteriori informazioni sui requisiti delle fasi di formazione, consulta [sagemaker.workflow.steps. TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep)documentazione.
```
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,
)
```
------
## Fase di ottimizzazione
Si utilizza una fase di ottimizzazione per creare un processo di ottimizzazione degli iperparametri, noto anche come ottimizzazione degli iperparametri (HPO). Un processo di ottimizzazione degli iperparametri esegue più job di addestramento, ognuno dei quali produce una versione del modello. Per ulteriori informazioni sull'ottimizzazione degli iperparametri, consulta [Ottimizzazione automatica dei modelli con AI SageMaker](automatic-model-tuning.md).
Il lavoro di ottimizzazione è associato all'esperimento di SageMaker intelligenza artificiale per la pipeline, mentre i lavori di formazione vengono creati come prove. Per ulteriori informazioni, consulta [Integrazione di Esperimenti](pipelines-experiments.md).
Una fase di ottimizzazione richiede un input di formazione [HyperparameterTuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html). È possibile addestrare nuovamente processi di ottimizzazione precedenti specificando il parametro `warm_start_config` del `HyperparameterTuner`. Per ulteriori informazioni sull'ottimizzazione degli iperparametri e sull'avvio a caldo, consulta [Eseguire un processo di ottimizzazione degli iperparametri con avvio a caldo](automatic-model-tuning-warm-start.md).
[Utilizzate il [metodo get\$1top\$1model\$1s3\$1uri di 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)classe per ottenere l'artefatto del modello da una delle versioni del modello con le migliori prestazioni. [Per un taccuino che mostra come utilizzare una fase di ottimizzazione in una pipeline di SageMaker intelligenza artificiale, consulta .ipynb. sagemaker-pipelines-tuning-step](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/tuning-step/sagemaker-pipelines-tuning-step.ipynb)
**Importante**
Le fasi di ottimizzazione sono state introdotte in Amazon SageMaker Python SDK v2.48.0 e Amazon Studio Classic v3.8.0. SageMaker Devi aggiornare Studio Classic prima di utilizzare una fase di ottimizzazione, in caso contrario il DAG della pipeline non viene visualizzato. Per aggiornare Studio Classic, consulta [Chiudi e aggiorna Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
L'esempio seguente mostra come creare una definizione di `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"))
)
```
**Ottenere la versione migliore del modello**
Nell'esempio seguente viene illustrato come ottenere la versione migliore del modello dal processo di ottimizzazione mediante il metodo `get_top_model_s3_uri`. Al massimo, le 50 versioni con le migliori prestazioni sono disponibili classificate in base a. [HyperParameterTuningJobObjective](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTuningJobObjective.html) L'argomento `top_k` è un indice delle versioni, dove `top_k=0` indica la versione con le migliori prestazioni e `top_k=49` quella con le prestazioni peggiori.
```
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()
),
...
)
```
[Per ulteriori informazioni sui requisiti delle fasi di ottimizzazione, consulta sagemaker.workflow.steps. TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)documentazione.
## Fase Fine-tuning
La messa a punto consente di addestrare un modello di base preaddestrato di Amazon SageMaker JumpStart su un nuovo set di dati. Questo processo, noto anche come trasferimento dell'apprendimento, può produrre modelli accurati con set di dati più piccoli e tempi di addestramento ridotti. Quando esegui il fine-tuning di un modello, puoi utilizzare il set di dati predefinito o scegliere i tuoi dati. Per ulteriori informazioni sulla messa a punto di un modello di base di, consulta. JumpStart [Ottimizzare un modello](jumpstart-fine-tune.md)
La fase di messa a punto utilizza un processo di SageMaker formazione di Amazon per personalizzare il modello. Verifica che il tuo ruolo IAM disponga delle autorizzazioni API `sagemaker:DescribeTrainingJob` e `sagemaker:CreateTrainingJob` necessarie per eseguire il processo di fine-tuning nella tua pipeline. Per ulteriori informazioni sulle autorizzazioni richieste per Amazon SageMaker AI e su come configurarle, consulta[Autorizzazioni API Amazon SageMaker AI: riferimento ad azioni, autorizzazioni e risorse](api-permissions-reference.md).
Per aggiungere una fase del **modello Fine-tune** alla tua pipeline utilizzando l' drag-and-dropeditor, segui questi passaggi:
1. Apri la console Studio seguendo le istruzioni riportate in [Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Scegli **Vuoto**.
1. Nella barra laterale sinistra, scegli **Fine-tuning di un modello** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Fine-tuning di un modello** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**.
1. Se il canvas include una fase immediatamente precedente alla fase **Fine-tuning di un modello** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Fine-tuning di un modello** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Fine-tuning di un modello** che hai aggiunto, fai clic e trascina il cursore dalla fase **Fine-tuning di un modello** all’altra fase per creare un arco.
## Fase AutoML
Utilizza l'API [AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html) per creare un processo AutoML per addestrare automaticamente un modello. Per ulteriori informazioni sui job AutoML, consulta [Automatizza lo sviluppo di modelli con Amazon](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html) Autopilot. SageMaker
**Nota**
Attualmente, la fase AutoML supporta solo la [modalità di addestramento di raggruppamento](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-model-support-validation.html).
L'esempio seguente mostra come creare una definizione utilizzando `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,
)
```
**Ottenere la versione migliore del modello**
La fase AutoML addestra automaticamente diversi candidati modello. È possibile ottenere il modello con la metrica obiettivo ottimale dal processo AutoML utilizzando il metodo `get_best_auto_ml_model` come segue. È inoltre necessario utilizzare un `role` IAM per accedere agli artefatti del modello.
```
best_model = step_automl.get_best_auto_ml_model(role=)
```
Per ulteriori informazioni, consulta il passaggio [AutoML](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.automl_step.AutoMLStep) in Python SageMaker SDK.
## Fase del modello
Usa `ModelStep` a per creare o registrare un SageMaker modello di intelligenza artificiale. Per ulteriori informazioni sui `ModelStep` requisiti, consulta [sagemaker.workflow.model\$1step. ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.model_step.ModelStep)documentazione.
### Creazione di un modello
Puoi usare `ModelStep` a per creare un modello di SageMaker intelligenza artificiale. A `ModelStep` richiede artefatti del modello e informazioni sul tipo di istanza SageMaker AI da utilizzare per creare il modello. Per ulteriori informazioni sui modelli di SageMaker intelligenza artificiale, consulta [Train a Model with Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html).
L'esempio seguente mostra come creare una definizione di `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"),
)
```
### Registrazione di un modello
Puoi usare `ModelStep` a per registrare un `sagemaker.model.Model` o un `sagemaker.pipeline.PipelineModel` con Amazon SageMaker Model Registry. Un `PipelineModel` rappresenta una pipeline di inferenza, che è un modello composto da una sequenza lineare di container che elaborano richieste di inferenza. Per ulteriori informazioni su come eseguire la registrazione di un modello, consulta [Implementazione della registrazione del modello con il registro dei modelli](model-registry.md).
L'esempio seguente mostra come creare una `ModelStep` per registrare 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,
)
```
## Fase Creazione di un modello
Utilizza una fase di creazione del modello per creare un modello di SageMaker intelligenza artificiale. Per ulteriori informazioni sui modelli di SageMaker intelligenza artificiale, consulta[Addestra un modello con Amazon SageMaker](how-it-works-training.md).
Una fase di creazione del modello richiede artefatti del modello e informazioni sul tipo di istanza SageMaker AI da utilizzare per creare il modello. Gli esempi seguenti mostrano come creare una definizione della fase Creazione di un modello. [Per ulteriori informazioni sui requisiti della fase di creazione del modello, consulta sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep)documentazione.
------
#### [ Pipeline Designer ]
Per aggiungere una fase di creazione del modello alla pipeline, procedi come descritto di seguito:
1. Apri la console Studio seguendo le istruzioni riportate in [Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Scegli **Vuoto**.
1. Nella barra laterale sinistra, scegli **Creazione di un modello** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Creazione di un modello** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**. Per informazioni sui campi di queste schede, consulta [sagemaker.workflow.steps. CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep).
1. Se il canvas include una fase immediatamente precedente alla fase **Creazione di un modello** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Creazione di un modello** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Creazione di un modello** che hai aggiunto, fai clic e trascina il cursore dalla fase **Creazione di un modello** all’altra fase per creare un arco.
------
#### [ SageMaker Python SDK ]
**Importante**
Ti consigliamo di [Fase del modello](#step-type-model) utilizzarlo per creare modelli a partire dalla v2.90.0 di AI SageMaker Python SDK. `CreateModelStep`continuerà a funzionare nelle versioni precedenti di SageMaker Python SDK, ma non è più supportato attivamente.
```
from sagemaker.workflow.steps import CreateModelStep
step_create_model = CreateModelStep(
name="AbaloneCreateModel",
model=best_model,
inputs=inputs
)
```
------
## Fase Registrazione di un modello
La fase Register model registra un modello nel Model Registry. SageMaker
------
#### [ Pipeline Designer ]
Per registrare un modello da una pipeline utilizzando Pipeline Designer, procedi come descritto di seguito:
1. Apri la console Amazon SageMaker Studio seguendo le istruzioni riportate in[Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Scegli **Vuoto**.
1. Nella barra laterale sinistra, scegli **Registrazione di un modello** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Registrazione di un modello** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**. Per informazioni sui campi di queste schede, consulta [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel).
1. Se il canvas include una fase immediatamente precedente alla fase **Registrazione di un modello** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Registrazione di un modello** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Registrazione di un modello** che hai aggiunto, fai clic e trascina il cursore dalla fase **Registrazione di un modello** all’altra fase per creare un arco.
------
#### [ SageMaker Python SDK ]
**Importante**
Si consiglia di utilizzare [Fase del modello](#step-type-model) per registrare i modelli a partire dalla v2.90.0 di AI SageMaker Python SDK. `RegisterModel`continuerà a funzionare nelle versioni precedenti di SageMaker Python SDK, ma non è più supportato attivamente.
[Si utilizza un `RegisterModel` passaggio per registrare 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 Amazon SageMaker Model Registry. Un `PipelineModel` rappresenta una pipeline di inferenza, che è un modello composto da una sequenza lineare di container che elaborano richieste di inferenza.
Per ulteriori informazioni su come eseguire la registrazione di un modello, consulta [Implementazione della registrazione del modello con il registro dei modelli](model-registry.md). Per ulteriori informazioni sui requisiti dei `RegisterModel` passaggi, consulta [sagemaker.workflow.step\$1collections. RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel)documentazione.
L'esempio seguente mostra come creare una fase `RegisterModel` per registrare 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',
)
```
Se `model` non viene fornito, la fase di registrazione del modello richiede uno strumento di valutazione come mostrato nell'esempio seguente.
```
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
)
```
------
## Fase Implementazione di un modello (endpoint)
In Pipeline Designer, utilizza la fase Implementazione di un modello (endpoint) per implementare il modello in un endpoint. Puoi creare un nuovo endpoint o utilizzarne uno esistente. L’inferenza in tempo reale è ideale per carichi di lavoro di inferenza in cui sono previsti requisiti in tempo reale, interattivi e a bassa latenza. Puoi implementare il tuo modello nei servizi di hosting SageMaker AI e ottenere un endpoint in tempo reale che può essere utilizzato per l'inferenza. Questi endpoint sono completamente gestiti e supportano il dimensionamento automatico. Per ulteriori informazioni sull'inferenza in tempo reale nell' SageMaker intelligenza artificiale, consulta. [Inferenza in tempo reale](realtime-endpoints.md)
Prima di aggiungere una fase Implementazione di un modello alla pipeline, verifica che il tuo ruolo IAM abbia le autorizzazioni seguenti:
+ `sagemaker:CreateModel`
+ `sagemaker:CreateEndpointConfig`
+ `sagemaker:CreateEndpoint`
+ `sagemaker:UpdateEndpoint`
+ `sagemaker:DescribeModel`
+ `sagemaker:DescribeEndpointConfig`
+ `sagemaker:DescribeEndpoint`
Per saperne di più su tutte le autorizzazioni richieste per l' SageMaker IA e su come configurarle, consulta. [Autorizzazioni API Amazon SageMaker AI: riferimento ad azioni, autorizzazioni e risorse](api-permissions-reference.md)
Per aggiungere una fase di implementazione del modello alla tua Pipeline nell' drag-and-dropeditor, completa i seguenti passaggi:
1. Apri la console Studio seguendo le istruzioni riportate in [Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Scegli **Vuoto**.
1. Nella barra laterale sinistra, scegli **Implementazione di un modello (endpoint)** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Implementazione di un modello (endpoint)** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**.
1. Se il canvas include una fase immediatamente precedente alla fase **Implementazione di un modello (endpoint)** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Implementazione di un modello (endpoint)** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Implementazione di un modello (endpoint)** che hai aggiunto, fai clic e trascina il cursore dalla fase **Implementazione di un modello (endpoint)** all’altra fase per creare un arco.
## Fase di trasformazione
Si utilizza una fase di trasformazione in modo che la trasformazione in batch esegua inferenza su un intero set di dati. Per ulteriori informazioni sulla trasformazione in batch, consulta [Trasformazioni in batch con pipeline di inferenza](inference-pipeline-batch.md).
Una fase di trasformazione richiede un trasformatore e i dati su cui eseguire la trasformazione in batch. L’esempio seguente mostra come creare una definizione della fase Trasformazione. Per ulteriori informazioni sui requisiti delle fasi di trasformazione, consulta [sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep)documentazione.
------
#### [ Pipeline Designer ]
Per aggiungere una fase di trasformazione in batch alla pipeline utilizzando l'editor drag-and-drop visivo, procedi come segue:
1. Apri la console Studio seguendo le istruzioni riportate in [Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Scegli **Vuoto**.
1. Nella barra laterale sinistra, scegli **Implementazione di un modello (trasformazione di batch)** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Implementazione di un modello (trasformazione batch)** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**. [Per informazioni sui campi di queste schede, consulta sagemaker.workflow.steps. TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep).
1. Se il canvas include una fase immediatamente precedente alla fase **Implementazione di un modello (trasformazione di batch)** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Implementazione di un modello (trasformazione di batch)** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Implementazione di un modello (trasformazione di batch)** che hai aggiunto, fai clic e trascina il cursore dalla fase **Implementazione di un modello (trasformazione di batch)** all’altra fase per creare un arco.
------
#### [ 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"),
)
```
------
## Fase Condizione
Si utilizza una fase condizionale per valutare la condizione delle proprietà della fase per valutare quale azione deve essere intrapresa successivamente nella pipeline.
Una fase di condizione richiede:
+ Un elenco di condizioni.
+ Un elenco di fasi da eseguire se la condizione restituisce `true`.
+ Un elenco di fasi da eseguire se la condizione restituisce `false`.
------
#### [ Pipeline Designer ]
Per aggiungere una fase di condizione a una pipeline utilizzando Pipeline Designer, procedi come descritto di seguito:
1. Apri la console Amazon SageMaker Studio seguendo le istruzioni riportate in[Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Scegli **Vuoto**.
1. Nella barra laterale sinistra, scegli **Condizione** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Condizione** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**. Per informazioni sui campi di queste schede, consulta [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.condition_step.ConditionStep).
1. Se il canvas include una fase immediatamente precedente alla fase **Condizione** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Condizione** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Condizione** che hai aggiunto, fai clic e trascina il cursore dalla fase **Condizione** all’altra fase per creare un arco.
------
#### [ SageMaker Python SDK ]
L'esempio seguente mostra come creare una definizione di `ConditionStep`.
**Limitazioni**
+ Pipelines non supporta l’utilizzo di fasi di condizione annidate. Non è possibile passare una fase condizionale come input per un'altra fase condizionale.
+ Una fase condizionale non può utilizzare fasi identiche in entrambi i rami. Se hai bisogno della stessa funzionalità di fase in entrambi i rami, duplica la fase e assegnale un nome diverso.
```
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=[]
)
```
Per ulteriori informazioni sui `ConditionStep` requisiti, consulta [sagemaker.workflow.condition\$1step. ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#conditionstep) Riferimento API. Per ulteriori informazioni sulle condizioni supportate, consulta *[Amazon SageMaker Pipelines - Conditions](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#conditions)* nella documentazione di SageMaker AI Python SDK.
------
## Fase di callback
Utilizza un `Callback` passaggio per aggiungere processi e AWS servizi aggiuntivi al tuo flusso di lavoro che non sono forniti direttamente da Amazon SageMaker Pipelines. Quando viene eseguita una fase di `Callback`, si verifica la seguente procedura:
+ Pipelines invia un messaggio a una coda Amazon Simple Queue Service (Amazon SQS) specificata dal cliente. Il messaggio contiene un token generato da Pipelines e un elenco di parametri di input fornito dal cliente. Dopo aver inviato il messaggio, Pipelines attende una risposta dal cliente.
+ Il cliente recupera il messaggio dalla coda Amazon SQS e avvia il processo personalizzato.
+ Al termine del processo, il cliente chiama una delle seguenti persone APIs e invia il token generato da Pipelines:
+ [SendPipelineExecutionStepSuccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepSuccess.html), insieme a un elenco di parametri di output
+ [SendPipelineExecutionStepFailure](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepFailure.html), insieme a un motivo del fallimento
+ La chiamata API fa sì che Pipelines continui o interrompa il processo della pipeline.
Per ulteriori informazioni sui requisiti dei `Callback` passaggi, consulta [sagemaker.workflow.callback\$1step. CallbackStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.callback_step.CallbackStep)documentazione. Per una soluzione completa, consulta [Extend SageMaker Pipelines per includere passaggi personalizzati utilizzando passaggi di callback](https://aws.amazon.com/blogs/machine-learning/extend-amazon-sagemaker-pipelines-to-include-custom-steps-using-callback-steps/).
**Importante**
`Callback`i passaggi sono stati introdotti in Amazon SageMaker Python SDK v2.45.0 e Amazon Studio Classic v3.6.2. SageMaker Devi aggiornare Studio Classic prima di utilizzare una fase `Callback`, in caso contrario il DAG della pipeline non viene visualizzato. Per aggiornare Studio Classic, consulta [Chiudi e aggiorna Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
L’esempio seguente illustra un’implementazione della procedura precedente.
```
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**
I parametri di output per `CallbackStep` non devono essere nidificati. Ad esempio, se si utilizza un dizionario nidificato come parametro di output, il dizionario viene trattato come una singola stringa (ad es. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Se fornisci un valore annidato, quando provi a fare riferimento a un particolare parametro di output, l' SageMaker IA genera un errore client non riproducibile.
**Comportamento di arresto**
Un processo di pipeline non si arresta durante l'esecuzione di una fase di `Callback`.
Quando [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)richiami un processo di pipeline con una `Callback` fase in esecuzione, Pipelines invia un messaggio Amazon SQS alla coda SQS. Il corpo del messaggio SQS contiene un campo **Stato**, impostato su `Stopping`. Nell'esempio seguente viene mostrato il corpo di un messaggio 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"
}
```
È opportuno aggiungere una logica al consumer del messaggio Amazon SQS affinché intraprenda le eventuali azioni necessarie (ad esempio, la pulizia delle risorse) al momento della ricezione del messaggio. Quindi, aggiungi una chiamata a `SendPipelineExecutionStepSuccess` o `SendPipelineExecutionStepFailure`.
Solo quando Pipelines riceve una di queste chiamate arresta il processo della pipeline.
## Fase Lambda
Si utilizza un passaggio Lambda per eseguire una AWS Lambda funzione. Puoi eseguire una funzione Lambda esistente oppure l' SageMaker IA può creare ed eseguire una nuova funzione Lambda. Se scegli di utilizzare una funzione Lambda esistente, questa deve essere nella Regione AWS stessa pipeline SageMaker AI. [Per un taccuino che mostra come utilizzare una fase Lambda in una pipeline SageMaker AI, consulta .ipynb. sagemaker-pipelines-lambda-step](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/lambda-step/sagemaker-pipelines-lambda-step.ipynb)
**Importante**
Le fasi Lambda sono state introdotte in Amazon SageMaker Python SDK v2.51.0 e Amazon Studio Classic v3.9.1. SageMaker Devi aggiornare Studio Classic prima di utilizzare una fase Lambda, in caso contrario il DAG della pipeline non viene visualizzato. Per aggiornare Studio Classic, consulta [Chiudi e aggiorna Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
SageMaker L'intelligenza artificiale fornisce la classe [SageMaker.lambda\$1helper.lambda per creare, aggiornare, richiamare ed eliminare funzioni Lambda](https://sagemaker.readthedocs.io/en/stable/api/utility/lambda_helper.html). `Lambda`ha la seguente 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
...
)
```
Il [sagemaker.workflow.lambda\$1step. LambdaStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.lambda_step.LambdaStep)la classe ha un argomento di tipo. `lambda_func` `Lambda` Per richiamare una funzione Lambda esistente, l'unico requisito è fornire il nome della risorsa Amazon (ARN) della funzione a `function_arn`. Se non fornisci un valore per `function_arn`, devi specificare `handler` e uno dei seguenti parametri:
+ `zipped_code_dir`: il percorso della funzione Lambda compressa
`s3_bucket`: bucket Amazon S3 dove deve essere caricato `zipped_code_dir`
+ `script`: il percorso del file di script della funzione Lambda
L'esempio seguente mostra come creare una definizione di fase `Lambda` che richiami una funzione Lambda esistente.
```
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"
]
)
```
L'esempio seguente mostra come creare una definizione di fase `Lambda` che crei e richiami una funzione Lambda utilizzando uno script di funzione 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"
]
)
```
**Input e output**
Se la funzione `Lambda` ha input o output, anche questi devono essere definiti nella fase `Lambda`.
**Nota**
I parametri di input e output non devono essere nidificati. Ad esempio, se si utilizza un dizionario nidificato come parametro di output, il dizionario viene trattato come una singola stringa (ad es. `{"output1": "{\"nested_output1\":\"my-output\"}"}`). Se si fornisce un valore nidificato e si tenta di farvi riferimento in un secondo momento, viene generato un errore irreversibile del client.
Quando si definisce la fase `Lambda`, `inputs` deve essere un dizionario di coppie chiave-valore. Ogni valore del dizionario `inputs` deve essere di tipo primitivo (stringa, numero intero o float). Gli oggetti nidificati non sono supportati. Se non viene definito, il valore `inputs` predefinito è `None`.
Il valore `outputs` deve essere un elenco di chiavi. Queste chiavi si riferiscono a un dizionario definito nell'output della funzione `Lambda`. Come per `inputs`, queste chiavi devono essere di tipo primitivo e gli oggetti nidificati non sono supportati.
**Comportamento di timeout e arresto**
La classe `Lambda` ha un argomento `timeout` che specifica il tempo massimo di esecuzione della funzione Lambda. Il valore predefinito è 120 secondi con un valore massimo di 10 minuti. Se la funzione Lambda è in esecuzione quando viene raggiunto il timeout, la fase Lambda ha esito negativo; tuttavia, la funzione Lambda continua a essere in esecuzione.
Un processo di pipeline non può essere arrestato mentre è in esecuzione una fase Lambda perché la funzione Lambda richiamata dalla fase Lambda non può essere arrestata. Se provi ad arrestare il processo mentre la funzione Lambda è in esecuzione, la pipeline attende che la funzione venga completata o raggiunga il timeout, a seconda dell’evento che si verifica per primo. A questo punto, il processo si arresta. Se la funzione Lambda termina, lo stato del processo di pipeline è `Stopped`. Se viene raggiunto il timeout, lo stato del processo di pipeline è `Failed`.
## ClarifyCheck passo
Si può utilizzare la fase `ClarifyCheck` per eseguire controlli della deviazione dalla baseline rispetto alle baseline precedenti per l'analisi dei bias e la spiegabilità del modello. È quindi possibile generare e [registrare le proprie baseline](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) con il metodo `model.register()` e passare l'output di tale metodo a [Fase del modello](#step-type-model) utilizzando `[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)`. Queste linee di base per il controllo della deriva possono essere utilizzate da Amazon SageMaker Model Monitor per gli endpoint del modello. Di conseguenza, non è necessario eseguire separatamente un suggerimento [baseline](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html).
La fase `ClarifyCheck` può anche estrarre le baseline per il controllo della deviazione dal registro dei modelli. La `ClarifyCheck` fase utilizza il contenitore predefinito Clarify SageMaker . Questo container offre una gamma di funzionalità di monitoraggio dei modelli, tra cui suggerimenti e convalida dei vincoli rispetto a una determinata baseline. Per ulteriori informazioni, consulta [Contenitori Clarify predefiniti SageMaker](clarify-processing-job-configure-container.md).
### Configurazione della fase ClarifyCheck
È possibile configurare la fase `ClarifyCheck` per eseguire solo uno dei seguenti tipi di controllo ogni volta che viene utilizzata in una pipeline.
+ Controllo dei bias nei dati
+ Controllo dei bias nel modello
+ Controllo della spiegabilità del modello
Per farlo, imposta il parametro `clarify_check_config` con uno dei valori del tipo di controllo seguenti:
+ `DataBiasCheckConfig`
+ `ModelBiasCheckConfig`
+ `ModelExplainabilityCheckConfig`
La `ClarifyCheck` fase avvia un processo di elaborazione che esegue il contenitore precostruito SageMaker AI Clarify e richiede [configurazioni dedicate per il controllo e il](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-configure-processing-jobs.html) processo di elaborazione. `ClarifyCheckConfig`e `CheckJobConfig` sono funzioni di supporto per queste configurazioni. Queste funzioni di supporto sono in linea con il modo in cui viene calcolato il processo di elaborazione di SageMaker Clarify per verificare la distorsione del modello, la distorsione dei dati o la spiegabilità del modello. Per ulteriori informazioni, consulta [Esegui SageMaker Clarify Processing Jobs per l'analisi e la spiegabilità dei pregiudizi](clarify-processing-job-run.md).
### Controllo dei comportamenti della fase per il controllo della deviazione
La fase `ClarifyCheck` richiede i seguenti due flag booleani per controllarne il comportamento:
+ `skip_check`: questo parametro indica se il controllo della deriva rispetto alla baseline precedente viene saltato o meno. Se è impostato su `False`, deve essere disponibile la baseline precedente del tipo di controllo configurato.
+ `register_new_baseline`: questo parametro indica se è possibile accedere a una baseline appena calcolata tramite la proprietà di fase `BaselineUsedForDriftCheckConstraints`. Se è impostato su `False`, deve essere disponibile anche la baseline precedente del tipo di controllo configurato. È possibile accedervi tramite la proprietà `BaselineUsedForDriftCheckConstraints`.
Per ulteriori informazioni, consulta [Calcolo di base, rilevamento della deriva e ciclo di vita con e ClarifyCheck fasi QualityCheck in Amazon Pipelines SageMaker](pipelines-quality-clarify-baseline-lifecycle.md).
### Utilizzo delle baseline
Puoi anche specificare `model_package_group_name` per individuare la baseline esistente. Quindi, la fase `ClarifyCheck` estrae `DriftCheckBaselines` nell’ultimo pacchetto di modelli approvato nel gruppo di pacchetti di modelli.
In alternativa, è possibile fornire una baseline precedente tramite il parametro `supplied_baseline_constraints`. Se si specificano sia `model_package_group_name` che `supplied_baseline_constraints`, la fase `ClarifyCheck` utilizza la baseline specificata dal parametro `supplied_baseline_constraints`.
[Per ulteriori informazioni sull'utilizzo dei requisiti dei passaggi, consultate sagemaker.workflow.steps. `ClarifyCheck` ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.clarify_check_step.ClarifyCheckStep)nell'*SDK Amazon SageMaker AI SageMaker AI per Python*. Per un notebook Amazon SageMaker Studio Classic che mostra come usare `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 Crea una fase `ClarifyCheck` per il controllo dei bias nei dati**
```
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 passaggio
Utilizza la fase `QualityCheck` per eseguire [suggerimenti baseline](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html) e controlli della deriva rispetto a una baseline precedente per verificare la qualità dei dati o del modello in una pipeline. Puoi quindi generare e [registrare le tue baseline](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations) con il metodo `model.register()` e passare l’output di tale metodo a [Fase del modello](#step-type-model) utilizzando `[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)`.
Model Monitor può usare queste baseline per il controllo della deviazione per gli endpoint del modello in modo da non dover eseguire un suggerimento di baseline separatamente. La fase `QualityCheck` può anche estrarre le baseline per il controllo della deviazione dal registro dei modelli. La `QualityCheck` fase sfrutta il container precostruito Amazon SageMaker AI Model Monitor. Questo container offre una gamma di funzionalità di monitoraggio dei modelli, tra cui la generazione di statistiche e i suggerimenti e la convalida dei vincoli rispetto a una determinata baseline. Per ulteriori informazioni, consulta [Contenitore precostruito Amazon SageMaker Model Monitor](model-monitor-pre-built-container.md).
### Configurazione della fase QualityCheck
Puoi configurare la fase `QualityCheck` per eseguire solo uno dei seguenti tipi di controllo ogni volta che viene utilizzato in una pipeline.
+ Controllo della qualità dei dati
+ Controllo della qualità del modello
È possibile eseguire questa operazione impostando il parametro `quality_check_config` con uno dei valori di tipo di controllo seguenti:
+ `DataQualityCheckConfig`
+ `ModelQualityCheckConfig`
La fase `QualityCheck` avvia un processo di elaborazione che esegue il container esistente di Model Monitor e richiede configurazioni dedicate per il controllo e il processo di elaborazione. `QualityCheckConfig` e `CheckJobConfig` sono funzioni di supporto per queste configurazioni. Queste funzioni di supporto sono in linea con il modo in cui Model Monitor crea una baseline per il monitoraggio della qualità del modello o dei dati. Per ulteriori informazioni sui suggerimenti di baseline di Model Monitor, consulta [Creazione di una linea di base](model-monitor-create-baseline.md) e [Creazione di una baseline per la qualità del modello](model-monitor-model-quality-baseline.md).
### Controllo dei comportamenti della fase per il controllo della deviazione
La fase `QualityCheck` richiede i seguenti due flag booleani per controllarne il comportamento:
+ `skip_check`: questo parametro indica se il controllo della deriva rispetto alla baseline precedente viene saltato o meno. Se è impostato su `False`, deve essere disponibile la baseline precedente del tipo di controllo configurato.
+ `register_new_baseline`: questo parametro indica se è possibile accedere a una baseline appena calcolata tramite le proprietà di fase `BaselineUsedForDriftCheckConstraints` e `BaselineUsedForDriftCheckStatistics`. Se è impostato su `False`, deve essere disponibile anche la baseline precedente del tipo di controllo configurato. È possibile accedervi tramite le proprietà `BaselineUsedForDriftCheckConstraints` e `BaselineUsedForDriftCheckStatistics`.
Per ulteriori informazioni, consulta [Calcolo di base, rilevamento della deriva e ciclo di vita con e ClarifyCheck fasi QualityCheck in Amazon Pipelines SageMaker](pipelines-quality-clarify-baseline-lifecycle.md).
### Utilizzo delle baseline
Puoi specificare una baseline precedente direttamente tramite i parametri `supplied_baseline_statistics` e `supplied_baseline_constraints`. Puoi anche specificare `model_package_group_name` per far sì che la fase `QualityCheck` estragga `DriftCheckBaselines` nell’ultimo pacchetto di modelli approvato nel gruppo di pacchetti di modelli.
Quando specifichi quanto segue, la fase `QualityCheck` utilizza la baseline indicata da `supplied_baseline_constraints` e `supplied_baseline_statistics` sul tipo di controllo della fase `QualityCheck`.
+ `model_package_group_name`
+ `supplied_baseline_constraints`
+ `supplied_baseline_statistics`
Per ulteriori informazioni sull'utilizzo dei requisiti dei `QualityCheck` passaggi, consulta [sagemaker.workflow.steps. QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.quality_check_step.QualityCheckStep)nell'*SDK Amazon SageMaker AI SageMaker AI per Python*. Per un notebook Amazon SageMaker Studio Classic che mostra come usare `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 Crea una fase `QualityCheck` per il controllo della qualità dei dati**
```
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"
)
```
## Fase EMR
Utilizza la fase [EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html) di Amazon SageMaker Pipelines per:
+ Elaborare le [fasi di Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-work-with-steps.html) in un cluster Amazon EMR in esecuzione.
+ Far sì che la pipeline crei e gestisca un cluster Amazon EMR per te.
Per ulteriori informazioni su Amazon EMR, consulta [ Nozioni di base su Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html).
La fase EMR richiede che `EMRStepConfig` includa la posizione del file JAR utilizzato dal cluster Amazon EMR e tutti gli argomenti da passare. Fornisci anche l’ID del cluster Amazon EMR se intendi eseguire la fase su un cluster EMR in esecuzione. Puoi anche passare la configurazione del cluster per eseguire la fase EMR su un cluster creato, gestito e terminato al posto tuo. Le sezioni seguenti includono esempi e collegamenti a notebook di esempio che illustrano entrambi i metodi.
**Nota**
Le fasi EMR richiedono che il ruolo passato alla pipeline disponga di autorizzazioni aggiuntive. Collega la [policy gestita da AWS : `AmazonSageMakerPipelinesIntegrations`](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol-pipelines.html#security-iam-awsmanpol-AmazonSageMakerPipelinesIntegrations) al tuo ruolo della pipeline o verifica che il ruolo includa le autorizzazioni specificate nella policy.
Se elabori una fase EMR su un cluster in esecuzione, puoi utilizzare solo un cluster che si trova in uno dei seguenti stati:
`STARTING`
`BOOTSTRAPPING`
`RUNNING`
`WAITING`
Se si elaborano fasi EMR su un cluster in esecuzione, è possibile avere al massimo 256 fasi EMR in uno stato `PENDING` su un cluster EMR. Le fasi EMR inviate oltre questo limite provocano un errore di esecuzione della pipeline. Puoi valutare l'utilizzo di [Policy di ripetizione per la fasi della pipeline](pipelines-retry-policy.md).
È possibile specificare l'ID o la configurazione del cluster, ma non entrambi.
La fase EMR si affida EventBridge ad Amazon per monitorare le modifiche nella fase EMR o nello stato del cluster. Se elabori il tuo processo Amazon EMR su un cluster in esecuzione, la fase EMR utilizza la regola `SageMakerPipelineExecutionEMRStepStatusUpdateRule` per monitorare lo stato della fase EMR. Se elabori il processo su un cluster creato per te dalla fase EMR, la fase utilizza la regola `SageMakerPipelineExecutionEMRClusterStatusRule` per monitorare le modifiche allo stato del cluster. Se vedi una di queste EventBridge regole nel tuo AWS account, non eliminarla, altrimenti la fase EMR potrebbe non essere completata.
**Aggiungi una fase di Amazon EMR alla tua pipeline**
Per aggiungere una fase EMR alla pipeline, procedi come segue:
+ Apri la console Studio seguendo le istruzioni in [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
+ Scegli **Create** (Crea).
+ Scegli **Vuoto**.
+ Nella barra laterale sinistra, scegli **Elaborazione di dati** e trascinalo sul canvas.
+ Nel canvas, scegli la fase **Elaborazione di dati** che hai aggiunto.
+ Nella barra laterale destra, sotto modalità, scegli **EMR (**gestito).
+ Nella barra laterale destra, completa i moduli nelle schede **Impostazioni e Dettagli**. [Per informazioni sui campi di queste schede, consulta sagemaker.workflow.fail\$1step. EMRstep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.emr_step.EMRStep).
**Avvio di un nuovo processo su un cluster Amazon EMR in esecuzione**
Per avviare un nuovo processo su un cluster Amazon EMR in esecuzione, passa l’ID cluster come stringa all’argomento `cluster_id` di `EMRStep`. L'esempio seguente illustra questa procedura.
```
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"
)
```
Per un notebook di esempio con indicazioni dettagliate per l’esempio completo, consulta [Fase EMR di Pipelines con cluster EMR in esecuzione](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-running-emr-cluster.ipynb).
**Avvio di un nuovo processo su un nuovo cluster Amazon EMR**
Per avviare un nuovo processo su un nuovo cluster creato per te da `EMRStep`, fornisci la configurazione del cluster come dizionario, Il dizionario deve avere la stessa struttura di una [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html)richiesta. Tuttavia, non includere i seguenti campi nella configurazione del cluster:
+ [`Name`]
+ [`Steps`]
+ [`AutoTerminationPolicy`]
+ [`Instances`][`KeepJobFlowAliveWhenNoSteps`]
+ [`Instances`][`TerminationProtected`]
Tutti gli altri argomenti `RunJobFlow` sono disponibili per l'uso nella configurazione del cluster. Per i dettagli sulla sintassi della richiesta, vedere [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html).
L’esempio seguente passa una configurazione del cluster a una definizione della fase EMR. Alla fase viene richiesto di avviare un nuovo processo su un nuovo cluster EMR. La configurazione del cluster EMR in questo esempio include le specifiche per i nodi primari e principali del cluster EMR. Per ulteriori informazioni sui tipi di nodo Amazon EMR, consulta [Informazioni sui tipi di nodi: nodi primari, principali e attività](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
)
```
Per un notebook di esempio con indicazioni dettagliate per l’esempio completo, consulta [Fase EMR di Pipelines con gestione del ciclo di vita del cluster](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-cluster-lifecycle-management.ipynb).
## Fase EMR senza server
Per aggiungere una fase EMR serverless alla pipeline, procedi come segue:
+ Apri la console Studio seguendo le istruzioni in [Launch Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html).
+ Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
+ Scegli **Create** (Crea).
+ Scegli **Vuoto**.
+ Nella barra laterale sinistra, scegli **Elaborazione di dati** e trascinalo sul canvas.
+ Nel canvas, scegli la fase **Elaborazione di dati** che hai aggiunto.
+ Nella barra laterale destra, sotto modalità, scegli **EMR (**serverless).
+ Nella barra laterale destra, compila i moduli nelle schede **Impostazioni** e Dettagli.
## Fase Processo del notebook
Usa `NotebookJobStep` a per eseguire SageMaker Notebook Job in modo non interattivo come fase della pipeline. Se crei la tua pipeline nell' drag-and-dropinterfaccia utente di Pipelines, usa la per eseguire il [Fase Esecuzione di codice](#step-type-executecode) tuo notebook. Per ulteriori informazioni su SageMaker Notebook Jobs, consulta. [SageMaker Lavori su notebook](notebook-auto-run.md)
`NotebookJobStep` richiede almeno un notebook di input, un URI dell’immagine e un nome del kernel. Per ulteriori informazioni sui requisiti dei passaggi di Notebook Job e su altri parametri che è possibile impostare per personalizzare il passaggio, vedere [sagemaker.workflow.steps. NotebookJobStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.notebook_job_step.NotebookJobStep).
L’esempio seguente utilizza un numero minimo di argomenti per definire `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
)
```
La fase `NotebookJobStep` della pipeline viene considerata come un lavoro svolto da un SageMaker notebook. Di conseguenza, monitora lo stato di esecuzione nella dashboard dei processi del notebook nell’interfaccia utente di Studio Classic includendo tag specifici con argomento `tags`. Per ulteriori informazioni sui tag da utilizzare, consulta [Visualizzazione dei processi del notebook nella dashboard dell’interfaccia utente di Studio](create-notebook-auto-run-sdk.md#create-notebook-auto-run-dash).
Inoltre, se pianifichi il lavoro sul notebook utilizzando l'SDK SageMaker Python, puoi specificare solo determinate immagini per eseguire il lavoro sul notebook. Per ulteriori informazioni, consulta [Vincoli di immagine per i lavori su notebook AI SageMaker Python SDK](notebook-auto-run-constraints.md#notebook-auto-run-constraints-image-sdk).
## Fase Errore
Utilizza un passaggio Fail per interrompere l'esecuzione di Amazon SageMaker Pipelines quando non viene raggiunta la condizione o lo stato desiderato. La fase Errore consente inoltre di inserire un messaggio di errore personalizzato, che indica la causa dell’errore di esecuzione della pipeline.
**Nota**
Quando una fase Errore e altre fasi della pipeline vengono eseguite simultaneamente, la pipeline non termina fino al completamento di tutte le fasi simultanee.
### Limitazioni all’utilizzo della fase Errore
+ Non è possibile aggiungere una fase Errore all’elenco `DependsOn` di altre fasi. Per ulteriori informazioni, consulta [Dipendenza personalizzata tra le fasi](build-and-manage-steps.md#build-and-manage-custom-dependency).
+ Le altre fasi non possono fare riferimento alla fase Errore. È *sempre* l'ultima fase dell'esecuzione di una pipeline.
+ Non puoi riprovare l’esecuzione di una pipeline che termina con una fase Errore.
Puoi creare il messaggio di errore della fase Errore sotto forma di stringa di testo statica. In alternativa, puoi anche utilizzare i [Parametri della pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-parameters.html), un’operazione [Esegui join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html?highlight=Join#sagemaker.workflow.functions.Join) o altre [proprietà della fase](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#build-and-manage-properties) per creare un messaggio di errore più informativo, se utilizzi l’SDK.
------
#### [ Pipeline Designer ]
Per aggiungere una fase Errore alla pipeline, procedi come descritto di seguito:
1. Apri la console Studio seguendo le istruzioni riportate in [Avvia Amazon SageMaker Studio](studio-updated-launch.md).
1. Nel riquadro di navigazione a sinistra, seleziona **Pipeline**.
1. Scegli **Create** (Crea).
1. Scegli **Vuoto**.
1. Nella barra laterale sinistra, scegli **Errore** e trascinalo sul canvas.
1. Nel canvas, scegli la fase **Errore** che hai aggiunto.
1. Nella barra laterale destra, completa i moduli nelle schede **Impostazioni** e **Dettagli**. [Per informazioni sui campi di queste schede, consulta sagemaker.workflow.fail\$1step. FailStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.fail_step.FailStep).
1. Se il canvas include una fase immediatamente precedente alla fase **Errore** che hai aggiunto, fai clic e trascina il cursore da tale fase alla fase **Errore** per creare un arco.
1. Se il canvas include una fase immediatamente successiva alla fase **Errore** che hai aggiunto, fai clic e trascina il cursore dalla fase **Errore** all’altra fase per creare un arco.
------
#### [ SageMaker Python SDK ]
**Example**
Il frammento di codice di esempio seguente utilizza una `FailStep` con un `ErrorMessage` configurato con Parametri della pipeline e un'operazione `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]
),
)
```
------
# Aggiungi integrazione
MLflow l'integrazione consente di utilizzare MLflow le pipeline per selezionare un server di tracciamento o un'applicazione serverless, scegliere un esperimento e registrare i parametri.
## Concetti chiave
**Creazione di app predefinite**: quando si accede all'editor visivo della pipeline, verrà creata MLflow un'applicazione predefinita.
**Pannello Integrazioni**: include un nuovo pannello di integrazioni MLflow, che puoi selezionare e configurare.
**Aggiorna app ed esperimento**: l'opzione per sovrascrivere l'applicazione e l'esperimento selezionati durante l'esecuzione della pipeline.
## Come funziona
+ Vai a **Pipeline Visual Editor**
+ Scegli **Integrazione** nella barra degli strumenti
+ Scegliere **MLflow**
+ Configura l' MLflow app e sperimenta
## Schermate di esempio
Pannello laterale delle integrazioni
![\[La descrizione delle cose da fare.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/screenshot-pipeline-1.png)
MLflow configurazione
![\[La descrizione delle cose da fare.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/screenshot-pipeline-2.png)
Come sovrascrivere l'esperimento durante l'esecuzione della pipeline
![\[La descrizione delle cose da fare.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/screenshot-pipeline-3.png)
## Proprietà della fase
Utilizza l’attributo `properties` per aggiungere dipendenze dei dati tra le fasi della pipeline. Le pipeline utilizzano queste dipendenze dei dati per costruire il DAG a partire dalla definizione della pipeline. È possibile fare riferimento a queste proprietà come valori segnaposto e vengono risolte in fase di runtime.
L'`properties`attributo di un passo Pipelines corrisponde all'oggetto restituito da una `Describe` chiamata per il tipo di lavoro SageMaker AI corrispondente. Per ogni tipo di processo, la chiamata `Describe` restituisce il seguente oggetto di risposta:
+ `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)
[Per verificare quali proprietà sono riferibili per ogni tipo di passaggio durante la creazione della dipendenza dei dati, consulta Data *[Dependency - Property Reference nell'SDK](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
## Parallelizzazione delle fasi
Quando una fase non dipende da nessuna altra fase, viene eseguita immediatamente dopo l’esecuzione della pipeline. Tuttavia, l'esecuzione di troppe fasi della pipeline in parallelo può esaurire rapidamente le risorse disponibili. Controlla il numero di fasi simultanee per l'esecuzione di una pipeline con `ParallelismConfiguration`.
L'esempio seguente utilizza `ParallelismConfiguration` per impostare il limite di fasi simultanee a cinque.
```
pipeline.create(
parallelism_config=ParallelismConfiguration(5),
)
```
## Dipendenza dei dati tra le fasi
È possibile definire la struttura del DAG specificando le relazioni dei dati tra le fasi. Per creare dipendenze dei dati tra le fasi, passa le proprietà di una fase come input a un'altra fase della pipeline. La fase che riceve l'input viene avviata solo dopo il termine dell'esecuzione della fase che fornisce l'input.
Una dipendenza dai dati utilizza la notazione nel seguente formato. JsonPath Questo formato attraversa il file delle proprietà JSON. Ciò significa che è possibile aggiungere tutte ** le istanze necessarie per raggiungere la proprietà annidata desiderata nel file. [Per ulteriori informazioni sulla JsonPath notazione, consulta il repository. JsonPath ](https://github.com/json-path/JsonPath)
```
.properties..
```
Di seguito viene illustrato come specificare un bucket Amazon S3 utilizzando la proprietà `ProcessingOutputConfig` di una fase di elaborazione.
```
step_process.properties.ProcessingOutputConfig.Outputs["train_data"].S3Output.S3Uri
```
Per creare la dipendenza dei dati, passa il bucket a una fase di addestramento come segue.
```
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
))
)
```
[Per verificare quali proprietà sono riferibili per ogni tipo di passaggio durante la creazione della dipendenza dei dati, consulta Data *[Dependency - Property Reference nell'SDK](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)* Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
## Dipendenza personalizzata tra le fasi
Quando specifichi una dipendenza dei dati, Pipelines fornisce la connessione dati tra le fasi. In alternativa, una fase può accedere ai dati di una fase precedente senza utilizzare direttamente Pipelines. In questo caso, puoi creare una dipendenza personalizzata che indichi a Pipelines di iniziare una fase solo dopo il termine dell’esecuzione di un’altra fase. Si crea una dipendenza personalizzata specificando l'attributo `DependsOn` di una fase.
Ad esempio, quanto segue definisce una fase `C` che inizia solo dopo la fine dell'esecuzione sia della fase `A` che della fase `B`.
```
{
'Steps': [
{'Name':'A', ...},
{'Name':'B', ...},
{'Name':'C', 'DependsOn': ['A', 'B']}
]
}
```
Pipelines genera un’eccezione di convalida se la dipendenza crea una dipendenza ciclica.
L'esempio seguente crea una fase di addestramento che inizia al termine di una fase di elaborazione.
```
processing_step = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step])
```
L'esempio seguente crea una fase di addestramento che non si avvia fino al termine dell'esecuzione di due diverse fasi di elaborazione.
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step_1, processing_step_2])
```
Di seguito viene fornito un modo alternativo per creare la dipendenza personalizzata.
```
training_step.add_depends_on([processing_step_1])
training_step.add_depends_on([processing_step_2])
```
L'esempio seguente crea una fase di addestramento che riceve input da una fase di elaborazione e attende il termine dell'esecuzione di una diversa fase di elaborazione.
```
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])
```
Nell'esempio seguente viene illustrato come recuperare un elenco di stringhe delle dipendenze personalizzate di una fase.
```
custom_dependencies = training_step.depends_on
```
## Immagini personalizzate in una fase
Puoi utilizzare una qualsiasi delle [immagini disponibili dell' SageMaker AI Deep Learning Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) quando crei una fase della tua pipeline.
Inoltre puoi utilizzare il tuo container con le fasi della pipeline. Poiché non puoi creare un’immagine dall’interno di Studio Classic, devi crearla con un altro metodo prima di utilizzarla con Pipelines.
Per utilizzare il tuo container personale durante la creazione delle fasi per la pipeline, includi l'URI dell'immagine nella definizione dello strumento di valutazione. Per ulteriori informazioni sull'utilizzo del tuo contenitore con l' SageMaker intelligenza artificiale, consulta [Usare i contenitori Docker con SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers.html) l'intelligenza artificiale.