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à.
# Panoramica su Pipelines
[Una pipeline Amazon SageMaker AI è una serie di passaggi interconnessi in grafo aciclico diretto (DAG) definiti utilizzando l'interfaccia utente o l' drag-and-dropSDK Pipelines.](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html) Puoi anche creare la tua pipeline con lo [schema JSON di definizione della pipeline](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/). La definizione JSON di DAG fornisce informazioni sui requisiti e sulle relazioni tra ogni fase della pipeline. La struttura del DAG di una pipeline è determinata dalle dipendenze dei dati tra le varie fasi. Queste dipendenze tra i dati vengono create quando le proprietà dell'output di una fase vengono trasmesse come input a un'altra fase. L'immagine seguente è un esempio di DAG di pipeline:
![\[\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/pipeline-full.png)
**Questo DAG di esempio include le fasi seguenti:**
1. `AbaloneProcess`, un’istanza della fase di [elaborazione](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), esegue uno script di pre-elaborazione sui dati utilizzati per l’addestramento. Ad esempio, lo script può inserire i valori mancanti, normalizzare i dati numerici o suddividere i dati nei set di dati di addestramento, convalida e test.
1. `AbaloneTrain`, un’istanza della fase di [addestramento](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-training), configura gli iperparametri e addestra un modello a partire dai dati di input pre-elaborati.
1. `AbaloneEval`, un’altra istanza della fase di [elaborazione](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing), valuta l’accuratezza del modello. Questa fase mostra un esempio di dipendenza dai dati: questa fase utilizza l’output del set di dati di test di `AbaloneProcess`.
1. `AbaloneMSECond`è un'istanza di una fase [Condition](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-condition) che, in questo esempio, verifica che il mean-square-error risultato della valutazione del modello sia inferiore a un determinato limite. Se il modello non soddisfa i criteri, l’esecuzione della pipeline si arresta.
1. L’esecuzione della pipeline procede con le fasi seguenti:
1. `AbaloneRegisterModel`, dove l' SageMaker intelligenza artificiale richiede una [RegisterModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-register-model)fase per registrare il modello come gruppo di pacchetti di modelli con versioni nell'Amazon SageMaker Model Registry.
1. `AbaloneCreateModel`, dove l' SageMaker intelligenza artificiale prevede una [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-create-model)fase per creare il modello in preparazione della trasformazione in batch. Nel`AbaloneTransform`, l' SageMaker intelligenza artificiale richiama una fase di [trasformazione](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-transform) per generare previsioni del modello su un set di dati specificato dall'utente.
Gli argomenti seguenti descrivono i concetti fondamentali di Pipelines. Per un tutorial che descrive l'implementazione di questi concetti, consulta [Azioni di Pipelines](pipelines-build.md).
**Topics**
+ [Struttura ed esecuzione della pipeline](build-and-manage-pipeline.md)
+ [Gestione degli accessi IAM](build-and-manage-access.md)
+ [Configurazione del supporto multi-account per Pipelines](build-and-manage-xaccount.md)
+ [Parametri della pipeline](build-and-manage-parameters.md)
+ [Fasi delle pipeline](build-and-manage-steps.md)
+ [Lift-and-shift Codice Python con il decoratore @step](pipelines-step-decorator.md)
+ [Passaggio dei dati tra le fasi](build-and-manage-propertyfile.md)
+ [Caching delle fasi della pipeline](pipelines-caching.md)
+ [Policy di ripetizione per la fasi della pipeline](pipelines-retry-policy.md)
+ [Esecuzione selettiva di fasi della pipeline](pipelines-selective-ex.md)
+ [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)
+ [Pianificazione delle esecuzioni della pipeline](pipeline-eventbridge.md)
+ [Integrazione con Amazon SageMaker Experiments](pipelines-experiments.md)
+ [Esecuzione delle pipeline con la modalità locale](pipelines-local-mode.md)
+ [Risoluzione dei problemi di Amazon SageMaker Pipelines](pipelines-troubleshooting.md)
# Struttura ed esecuzione della pipeline
**Topics**
+ [Struttura della pipeline](#build-and-manage-pipeline-structure)
+ [Esecuzione della pipeline utilizzando la configurazione del parallelismo](#build-and-manage-pipeline-execution)
## Struttura della pipeline
Un'istanza Amazon SageMaker Pipelines è composta da un `name``parameters`, e`steps`. I nomi delle pipeline devono essere univoci all'interno di una coppia `(account, region)`. Tutti i parametri utilizzati nelle definizioni delle fasi devono essere definiti nella pipeline. Le fasi della pipeline elencate determinano automaticamente il loro ordine di esecuzione in base alle reciproche dipendenze dei dati. Il servizio Pipelines risolve le relazioni tra le fasi del DAG di dipendenza dai dati per creare una serie di fasi completate dall’esecuzione. Il seguente è un esempio di struttura di pipeline.
**avvertimento**
Quando crei una pipeline tramite l'editor visivo o l'SDK SageMaker AI Python, non includere informazioni sensibili nei parametri della pipeline o in alcun campo di definizione dei passaggi (come le variabili di ambiente). Questi campi saranno visibili in futuro quando verranno restituiti in una richiesta `DescribePipeline`.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline_name = f"AbalonePipeline"
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_type,
processing_instance_count,
training_instance_type,
model_approval_status,
input_data,
batch_data,
],
steps=[step_process, step_train, step_eval, step_cond],
)
```
## Esecuzione della pipeline utilizzando la configurazione del parallelismo
Per impostazione predefinita, una pipeline esegue tutte le fasi disponibili per l'esecuzione in parallelo. È possibile controllare questo comportamento utilizzando la proprietà `ParallelismConfiguration` durante la creazione o l'aggiornamento di una pipeline, nonché quando si avvia o si ritenta l'esecuzione di una pipeline.
Le configurazioni di parallelismo vengono applicate per ogni esecuzione. Ad esempio, se vengono avviate due esecuzioni, ciascuna può eseguire un massimo di 50 passaggi contemporaneamente, per un totale di 100 fasi in esecuzione simultanea. Inoltre, qualsiasi `ParallelismConfiguration` all'avvio, al nuovo tentativo o all'aggiornamento di un'esecuzione ha la precedenza sulle configurazioni di parallelismo definite nella pipeline.
**Example Creazione di un'esecuzione di pipeline con `ParallelismConfiguration`**
```
pipeline = Pipeline(
name="myPipeline",
steps=[step_process, step_train]
)
pipeline.create(role, parallelism_config={"MaxParallelExecutionSteps": 50})
```
# Gestione degli accessi IAM
Le seguenti sezioni descrivono i requisiti AWS Identity and Access Management (IAM) per Amazon SageMaker Pipelines. Per un esempio di implementazione delle autorizzazioni, consulta [Prerequisiti](define-pipeline.md#define-pipeline-prereq).
**Topics**
+ [Autorizzazioni relative ai ruoli della pipeline](#build-and-manage-role-permissions)
+ [Autorizzazioni relative alle fasi della pipeline](#build-and-manage-step-permissions)
+ [Configurazione CORS con bucket Amazon S3](#build-and-manage-cors-s3)
+ [Personalizzazione della gestione degli accessi per i processi Pipelines](#build-and-manage-step-permissions-prefix)
+ [Personalizzazione dell’accesso alle versioni della pipeline](#build-and-manage-step-permissions-version)
+ [Policy di controllo dei servizi con Pipelines](#build-and-manage-scp)
## Autorizzazioni relative ai ruoli della pipeline
La tua pipeline richiede un ruolo di esecuzione della pipeline IAM che viene passato a Pipelines quando crei una pipeline. Il ruolo per l'istanza di SageMaker intelligenza artificiale che stai utilizzando per creare la pipeline deve avere una policy con l'`iam:PassRole`autorizzazione che specifichi il ruolo di esecuzione della pipeline. Questo perché l'istanza necessita dell'autorizzazione per passare il ruolo di esecuzione della pipeline al servizio Pipelines da utilizzare nella creazione e nell'esecuzione di pipeline. Per ulteriori informazioni sui ruoli IAM, consulta [Ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Il ruolo di esecuzione della pipeline richiede le seguenti autorizzazioni:
+ Puoi utilizzare un ruolo unico o personalizzato per qualsiasi fase del processo di SageMaker intelligenza artificiale nella tua pipeline (anziché il ruolo di esecuzione della pipeline, che viene utilizzato per impostazione predefinita). Assicurati che al tuo ruolo di esecuzione della pipeline sia stata aggiunta una policy con l'`iam:PassRole`autorizzazione che specifichi ciascuno di questi ruoli.
+ Autorizzazioni `Create` e `Describe` per ogni tipo di processo nella pipeline.
+ Autorizzazioni Amazon S3 per utilizzare la funzione `JsonGet`. È possibile controllare l’accesso alle risorse Amazon S3 utilizzando policy basate sulle identità e sulle risorse. Al bucket Amazon S3 viene applicata una policy basata sulle risorse, che consente a Pipelines di accedere al bucket. Una policy basata sull'identità offre alla tua pipeline la possibilità di effettuare chiamate Amazon S3 dal tuo account. Per ulteriori informazioni sulle differenze basate sulle risorse e sulle identità, consulta [Policy basate sulle identità e policy basate su risorse](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html).
```
{
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::/*",
"Effect": "Allow"
}
```
## Autorizzazioni relative alle fasi della pipeline
Le pipeline includono passaggi che SageMaker eseguono lavori di intelligenza artificiale. Affinché le fasi della pipeline eseguano questi processi, è richiesto un ruolo IAM nell'account che fornisca l'accesso alla risorsa necessaria. Questo ruolo viene trasferito al responsabile del servizio di SageMaker intelligenza artificiale dalla tua pipeline. Per ulteriori informazioni sui ruoli IAM, consulta [Ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html).
Per impostazione predefinita, ogni fase assume il ruolo di esecuzione della pipeline. Facoltativamente, puoi assegnare un ruolo diverso a qualsiasi fase della pipeline. Ciò garantisce che il codice di ogni fase non abbia la possibilità di influire sulle risorse utilizzate in altre fasi, a meno che non esista una relazione diretta tra le due fasi specificate nella definizione della pipeline. Questi ruoli vengono trasmessi quando si definisce lo strumento di elaborazione o valutazione per la propria fase. Per esempi su come includere questi ruoli in queste definizioni, consulta la documentazione di [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#using-estimators).
## Configurazione CORS con bucket Amazon S3
Per garantire che le immagini vengano importate nelle pipeline da un bucket Amazon S3 in modo prevedibile, è necessario aggiungere una configurazione CORS ai bucket Amazon S3 da cui vengono importate le immagini. Questa sezione fornisce istruzioni su come impostare la configurazione CORS richiesta per il bucket Amazon S3. La `CORSConfiguration` XML richiesta per Pipelines è diversa da quella in [Requisito CORS per i dati delle immagini di input](sms-cors-update.md). In alternativa, consulta queste informazioni per saperne di più sul requisito CORS per i bucket Amazon S3.
Utilizza il codice di configurazione CORS seguente per i bucket Amazon S3 che ospitano le tue immagini. Per istruzioni sulla configurazione CORS, consulta [Configuring cross-origin resource sharing (CORS)](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-cors-configuration.html) in Amazon Simple Storage Service User Guide. Se utilizzi la console Amazon S3 per aggiungere la policy al tuo bucket, devi utilizzare il formato JSON.
**JSON**
```
[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"PUT"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": [
"Access-Control-Allow-Origin"
]
}
]
```
**XML**
```
**PUTAccess-Control-Allow-Origin
```
La seguente GIF illustra le istruzioni contenute nella documentazione di Amazon S3 per aggiungere una policy di intestazione CORS utilizzando la console Amazon S3.
![\[Gif su come aggiungere una policy di intestazione CORS utilizzando la console di Amazon S3.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/sms/gifs/cors-config.gif)
## Personalizzazione della gestione degli accessi per i processi Pipelines
Puoi personalizzare ulteriormente le tue policy IAM in modo che membri selezionati della tua organizzazione possano eseguire alcune o tutte le fasi della pipeline. Ad esempio, puoi concedere a determinati utenti l'autorizzazione a creare processi di addestramento, a un altro gruppo di utenti l'autorizzazione a creare processi di elaborazione e a tutti gli utenti l'autorizzazione a eseguire le fasi rimanenti. Per utilizzare questa funzionalità, seleziona una stringa personalizzata con il prefisso del nome del processo. L'amministratore aggiunge il prefisso a «permesso ARNs », mentre il data scientist include questo prefisso nelle istanze della pipeline. Poiché la policy IAM per gli utenti autorizzati contiene un ARN di processo con il prefisso specificato, i processi successivi della fase della pipeline dispongono delle autorizzazioni necessarie per procedere. Il prefisso del processo è disattivato per impostazione predefinita: devi attivare questa opzione nella tua classe `Pipeline` per utilizzarla.
Per i processi con il prefisso disattivato, il nome del processo è formattato come mostrato e rappresentato da una concatenazione di campi, come descritto nella tabella seguente:
`pipelines----`
| Campo | Definizione |
| --- | --- |
| pipelines | Una stringa statica sempre anteposta. Questa stringa identifica il servizio di orchestrazione della pipeline come origine del processo. |
| executionId | Un buffer randomizzato per l'istanza in esecuzione della pipeline. |
| stepNamePrefix | Il nome della fase specificato dall'utente (fornito nell'argomento `name` della fase della pipeline), limitato ai primi 20 caratteri. |
| entityToken | Un token randomizzato per garantire l'idempotenza dell'entità della fase. |
| failureCount | Il numero attuale di tentativi effettuati per completare il lavoro. |
In questo caso, al nome del processo non viene aggiunto alcun prefisso personalizzato; la policy IAM corrispondente deve corrispondere a questa stringa.
Per gli utenti che attivano il prefisso del processo, il nome del processo sottostante assume la forma seguente, con il prefisso personalizzato specificato come `MyBaseJobName`:
**-**-**-**
Il prefisso personalizzato sostituisce la `pipelines` stringa statica per aiutarti a restringere la selezione di utenti che possono eseguire il job AI come parte di una pipeline. SageMaker
**Restrizioni sulla lunghezza del prefisso**
I nomi dei processi hanno vincoli di lunghezza interni specifici per le singole fasi della pipeline. I vincoli limitano anche la lunghezza consentita del prefisso. I requisiti di lunghezza del prefisso sono i seguenti:
| Fase della pipeline | Lunghezza del prefisso |
| --- | --- |
| `[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`, `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`, `[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`, `[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`, `[ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)`, `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)`, `[RegisterModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)` | 38 |
| `[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`, `[AutoML](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)` | 6 |
### Applicazione di prefissi dei processi a una policy IAM
L’amministratore crea policy IAM che consentono agli utenti con prefissi specifici di creare lavori. La seguente policy di esempio consente ai data scientist di creare processi di addestramento se utilizzano il prefisso `MyBaseJobName`.
```
{
"Action": "sagemaker:CreateTrainingJob",
"Effect": "Allow",
"Resource": [
"arn:aws:sagemaker:region:account-id:*/MyBaseJobName-*"
]
}
```
### Applicazione di prefissi dei processi alle istanze della pipeline
Specifica il prefisso con l'argomento `*base_job_name` della classe dell’istanza di processo.
**Nota**
Trasmetti il prefisso del processo con l'argomento `*base_job_name` all'istanza del processo prima di creare una fase della pipeline. Questa istanza di processo contiene le informazioni necessarie affinché il processo venga eseguito come fase di una pipeline. Questo argomento varia a seconda dell'istanza di processo utilizzata. L'elenco seguente mostra quale argomento utilizzare per ogni tipo di fase della pipeline:
`base_job_name` per le classi `[Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html)` (`[TrainingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#trainingstep)`), `[Processor](https://sagemaker.readthedocs.io/en/stable/api/training/processing.html)` (`[ProcessingStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#processingstep)`) e `[AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html)` (`[AutoMLStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#automlstep)`)
`tuning_base_job_name` per la classe `[Tuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html)` (`[TuningStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#tuningstep)`)
`transform_base_job_name` per la classe `[Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html)` (`[TransformStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#transformstep)`)
`base_job_name` su `[CheckJobConfig](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#checkjobconfig)` per le classi `[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)` (Quality Check) e `[ClarifyCheckstep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)` (Clarify Check)
Per la classe `[Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html)`, l'argomento utilizzato dipende dal fatto che si esegua `create` o `register` dal modello prima di trasmettere il risultato a `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)`
Se si chiama `create`, il prefisso personalizzato deriva dall'argomento `name`quando si costruisce il modello (ad esempio, `Model(name=)`)
Se si chiama `register`, il prefisso personalizzato deriva dall'argomento `model_package_name` della chiamata a `register` (ad esempio, `my_model.register(model_package_name=)`)
L'esempio seguente mostra come specificare un prefisso per una nuova istanza del processo di addestramento.
```
# Create a job instance
xgb_train = Estimator(
image_uri=image_uri,
instance_type="ml.m5.xlarge",
instance_count=1,
output_path=model_path,
role=role,
subnets=["subnet-0ab12c34567de89f0"],
base_job_name="MyBaseJobName"
security_group_ids=["sg-1a2bbcc3bd4444e55"],
tags = [ ... ]
encrypt_inter_container_traffic=True,
)
# Attach your job instance to a pipeline step
step_train = TrainingStep(
name="TestTrainingJob",
estimator=xgb_train,
inputs={
"train": TrainingInput(...),
"validation": TrainingInput(...)
}
)
```
Per impostazione predefinita, l'aggiunta del prefisso al processo è disattivata. Per attivare questa funzionalità, utilizza l'opzione `use_custom_job_prefix` di `PipelineDefinitionConfig` come mostrato nel seguente frammento:
```
from sagemaker.workflow.pipeline_definition_config import PipelineDefinitionConfig
# Create a definition configuration and toggle on custom prefixing
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True);
# Create a pipeline with a custom prefix
pipeline = Pipeline(
name="MyJobPrefixedPipeline",
parameters=[...]
steps=[...]
pipeline_definition_config=definition_config
)
```
Crea ed esegui la tua pipeline. L'esempio seguente crea ed esegue una pipeline e illustra anche come disattivare l'aggiunta del prefisso ai progetti e rieseguire la pipeline.
```
pipeline.create(role_arn=sagemaker.get_execution_role())
# Optionally, call definition() to confirm your prefixed job names are in the built JSON
pipeline.definition()
pipeline.start()
# To run a pipeline without custom-prefixes, toggle off use_custom_job_prefix, update the pipeline
# via upsert() or update(), and start a new run
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=False)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Allo stesso modo, è possibile attivare la funzionalità per le pipeline esistenti e iniziare una nuova esecuzione che utilizza i prefissi dei processi.
```
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
Infine, puoi visualizzare il tuo processo con prefisso personalizzato chiamando `list_steps` sull'esecuzione della pipeline.
```
steps = execution.list_steps()
prefixed_training_job_name = steps['PipelineExecutionSteps'][0]['Metadata']['TrainingJob']['Arn']
```
## Personalizzazione dell’accesso alle versioni della pipeline
Puoi concedere un accesso personalizzato a versioni specifiche di Amazon SageMaker Pipelines utilizzando la chiave di `sagemaker:PipelineVersionId` condizione. Ad esempio, la policy riportata di seguito consente l’accesso per avviare esecuzioni o aggiornare la versione della pipeline solo per la versione con ID 6 e superiore.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowStartPipelineExecution",
"Effect": "Allow",
"Action": [
"sagemaker:StartPipelineExecution",
"sagemaker:UpdatePipelineVersion"
],
"Resource": "*",
"Condition": {
"NumericGreaterThanEquals": {
"sagemaker:PipelineVersionId": 6
}
}
}
}
```
------
Per ulteriori informazioni sulle chiavi di condizione supportate, consulta [Condition keys for Amazon SageMaker AI](https://docs.aws.amazon.com//service-authorization/latest/reference/list_amazonsagemaker.html#amazonsagemaker-policy-keys).
## Policy di controllo dei servizi con Pipelines
Le policy di controllo dei servizi (SCPs) sono un tipo di politica organizzativa che puoi utilizzare per gestire le autorizzazioni all'interno della tua organizzazione. SCPs offrono il controllo centralizzato sulle autorizzazioni massime disponibili per tutti gli account dell'organizzazione. Utilizzando Pipelines all'interno della vostra organizzazione, potete assicurarvi che i data scientist gestiscano le esecuzioni della pipeline senza dover interagire con la console. AWS
Se utilizzi un VPC con SCP che limita l'accesso ad Amazon S3, devi eseguire le fasi necessarie per consentire alla pipeline di accedere ad altre risorse Amazon S3.
Per consentire a Pipelines di accedere ad Amazon S3 al di fuori del VPC con la funzione `JsonGet`, aggiorna la SCP dell’organizzazione per garantire che il ruolo che utilizza Pipelines possa accedere ad Amazon S3. Per farlo, crea un’eccezione per i ruoli utilizzati dall’esecutore di Pipelines tramite il ruolo di esecuzione della pipeline includendo un tag principale e una chiave di condizione.
**Per consentire a Pipelines di accedere ad Amazon S3 al di fuori del tuo VPC**
1. Crea un tag unico per il tuo ruolo di esecuzione della pipeline seguendo la procedura descritta in [Tagging di utenti e ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html).
1. Concedi un'eccezione nel tuo SCP utilizzando la chiave di condizione `Aws:PrincipalTag IAM` per il tag che hai creato. Per ulteriori informazioni, consulta [Creazione, aggiornamento ed eliminazione delle policy di controllo del servizio](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_create.html).
# Configurazione del supporto multi-account per Pipelines
Il supporto multiaccount per Amazon SageMaker Pipelines ti consente di collaborare su pipeline di machine learning con altri team o organizzazioni che operano con account diversi. AWS Configurando la condivisione della pipeline multi-account, puoi concedere l’accesso controllato alle pipeline, consentire ad altri account di visualizzare i dettagli della pipeline e attivare e monitorare le esecuzioni. L'argomento seguente illustra come configurare la condivisione della pipeline tra account, le diverse politiche di autorizzazione disponibili per le risorse condivise e come accedere e interagire con entità di pipeline condivise tramite chiamate API dirette all'IA. SageMaker
## Configurazione della condivisione multi-account di pipeline
SageMaker L'intelligenza artificiale utilizza [AWS Resource Access Manager](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html) (AWS RAM) per aiutarti a condividere in modo sicuro le entità della pipeline tra gli account.
### Creare una condivisione di risorse
1. Seleziona **Crea una condivisione di risorse** tramite la console [AWS RAM](https://console.aws.amazon.com/ram/home).
1. Quando specifichi i dettagli della condivisione di risorse, scegli il tipo di risorsa Pipelines e seleziona una o più pipeline da condividere. Quando condividi una pipeline con qualsiasi altro account, anche tutte le sue esecuzioni vengono condivise implicitamente.
1. Associare autorizzazioni alla condivisione di risorse. Scegli la policy di autorizzazione di sola lettura predefinita o la policy di autorizzazione all'esecuzione della pipeline estesa. Per informazioni più dettagliate, consulta [Policy di autorizzazione per le risorse Pipelines](#build-and-manage-xaccount-permissions).
**Nota**
Se selezioni la politica di esecuzione della pipeline estesa, tieni presente che tutti i comandi di avvio, arresto e riprova richiamati dagli account condivisi utilizzano le risorse dell' AWS account che ha condiviso la pipeline.
1. Utilizza AWS account IDs per specificare gli account a cui desideri concedere l'accesso alle tue risorse condivise.
1. Controlla la configurazione della condivisione di risorse e seleziona **Crea condivisione di risorse**. Il completamento dell'associazione tra la condivisione di risorse e il principale potrebbe richiedere alcuni minuti.
Per ulteriori informazioni, consulta la sezione [Condivisione delle risorse AWS](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html) nella *Guida per l'utente di AWS Resource Access Manager*.
### Ottenere risposte all'invito alla condivisione di risorse
Una volta impostate le associazioni tra la condivisione di risorse e il principale, gli account AWS specificati ricevono un invito a partecipare alla condivisione di risorse. Gli AWS account devono accettare l'invito per accedere a qualsiasi risorsa condivisa.
Per ulteriori informazioni sull'accettazione di un invito alla condivisione di risorse tramite AWS RAM, vedere [Using shared AWS resources](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-shared.html) nella *AWS Resource Access Manager User Guide*.
## Policy di autorizzazione per le risorse Pipelines
Quando crei la tua condivisione di risorse, scegli una delle due politiche di autorizzazione supportate da associare al tipo di risorsa della pipeline SageMaker AI. Entrambe le policy concedono l'accesso a qualsiasi pipeline selezionata e a tutte le sue esecuzioni.
### Autorizzazioni di sola lettura predefinite
La policy `AWSRAMDefaultPermissionSageMakerPipeline` seguente consente le seguenti operazioni in sola lettura:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:Search"
```
### Autorizzazioni all'esecuzione della pipeline estese
La policy `AWSRAMPermissionSageMakerPipelineAllowExecution` include tutte le autorizzazioni di sola lettura previste dalla policy predefinita e consente inoltre agli account condivisi di avviare, arrestare e riprovare le esecuzioni della pipeline.
**Nota**
Fai attenzione all'utilizzo delle AWS risorse quando utilizzi la politica di autorizzazione all'esecuzione della pipeline estesa. Con questa policy, gli account condivisi possono avviare, arrestare e riprovare le esecuzioni della pipeline. Tutte le risorse utilizzate per le esecuzioni condivise della pipeline vengono consumate dall'account proprietario.
La policy di autorizzazione all'esecuzione della pipeline estesa consente le seguenti operazioni:
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:StartPipelineExecution"
"sagemaker:StopPipelineExecution"
"sagemaker:RetryPipelineExecution"
"sagemaker:Search"
```
## Accesso alle entità pipeline condivise tramite chiamate API dirette
Una volta configurata la condivisione della pipeline tra account, puoi chiamare le seguenti azioni SageMaker API utilizzando un ARN della pipeline:
**Nota**
È possibile chiamare i comandi API solo se sono inclusi nelle autorizzazioni associate alla condivisione di risorse. Se selezioni la `AWSRAMPermissionSageMakerPipelineAllowExecution` policy, i comandi start, stop e retry utilizzano le risorse dell' AWS account che ha condiviso la pipeline.
+ [DescribePipeline](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipeline.html)
+ [DescribePipelineDefinitionForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineDefinitionForExecution.html)
+ [DescribePipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribePipelineExecution.html)
+ [ListPipelineExecutions](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutions.html)
+ [ListPipelineExecutionSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineExecutionSteps.html)
+ [ListPipelineParametersForExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListPipelineParametersForExecution.html)
+ [StartPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StartPipelineExecution.html)
+ [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html)
+ [RetryPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RetryPipelineExecution.html)
# Parametri della pipeline
È possibile introdurre variabili nella definizione della pipeline utilizzando i parametri. È possibile fare riferimento ai parametri definiti durante la definizione di pipeline. I parametri hanno un valore predefinito, che è possibile sostituire specificando i valori dei parametri all'avvio dell'esecuzione di una pipeline. Il valore predefinito deve essere un'istanza che corrisponde al tipo di parametro. Tutti i parametri utilizzati nelle definizioni delle fasi devono essere definiti nella definizione di pipeline. Questo argomento descrive i parametri che è possibile definire e come implementarli.
Amazon SageMaker Pipelines supporta i seguenti tipi di parametri:
+ `ParameterString`: rappresenta un parametro di stringa.
+ `ParameterInteger`: rappresenta un parametro con numero intero.
+ `ParameterFloat`: rappresenta un parametro float.
+ `ParameterBoolean`: rappresenta un tipo booleano Python.
I parametri assumono il seguente formato:
```
= (
name="",
default_value=
)
```
Di seguito è mostrata un'implementazione di parametri di esempio.
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
ParameterFloat,
ParameterBoolean
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
```
Si passa il parametro durante la creazione della pipeline, come nell'esempio seguente.
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count
],
steps=[step_process]
)
```
È possibile anche passare un valore di parametro diverso dal valore predefinito all'esecuzione di una pipeline, come mostrato nell'esempio seguente.
```
execution = pipeline.start(
parameters=dict(
ProcessingInstanceCount="2",
ModelApprovalStatus="Approved"
)
)
```
Puoi manipolare i parametri con funzioni SageMaker Python SDK come. `[ sagemaker.workflow.functions.Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.functions.Join)` [Per ulteriori informazioni sui parametri, consulta SageMaker Pipelines Parameters.](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#parameters)
Per le limitazioni note dei parametri di Pipelines, consulta *[Limitazioni - Parametrizzazione nell'SDK](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#parameterization)* Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable).
# 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.
# Lift-and-shift Codice Python con il decoratore @step
Il decoratore `@step` è una funzionalità che converte il codice locale di machine learning (ML) in una o più fasi della pipeline. Puoi scrivere la tua funzione di ML come faresti per qualsiasi progetto di ML. Una volta testata localmente o come lavoro di formazione utilizzando il `@remote` decoratore, puoi convertire la funzione in una fase della pipeline SageMaker AI aggiungendo un decoratore. `@step` Puoi quindi passare a Pipelines l’output della chiamata alla funzione decorata con `@step` come fase per creare ed eseguire una pipeline. Puoi concatenare una serie di funzioni con il decoratore `@step` anche per creare una pipeline con grafo aciclico orientato (DAG) con più fasi.
La configurazione per utilizzare il decoratore `@step` è uguale a quella per il decoratore `@remote`. Puoi fare riferimento alla documentazione della funzione remota per dettagli su come [configurare l’ambiente](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator.html#train-remote-decorator-env) e [utilizzare un file di configurazione](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html) per impostare i valori predefiniti. Per ulteriori informazioni sul decoratore `@step`, consulta [sagemaker.workflow.function\$1step.step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.step).
Per visualizzare alcuni esempi di notebook che mostrano l’utilizzo del decoratore `@step`, consulta [@step decorator sample notebooks](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-pipelines/step-decorator).
Le sezioni seguenti spiegano come annotare il codice di ML locale con un decoratore `@step` per creare una fase, creare ed eseguire una pipeline con tale fase e personalizzare l’esperienza in base al tuo caso d’uso.
**Topics**
+ [Creazione di una pipeline con funzioni decorate con `@step`](pipelines-step-decorator-create-pipeline.md)
+ [Esecuzione di una pipeline](pipelines-step-decorator-run-pipeline.md)
+ [Configurazione della pipeline](pipelines-step-decorator-cfg-pipeline.md)
+ [Best practice](pipelines-step-decorator-best.md)
+ [Limitazioni](pipelines-step-decorator-limit.md)
# Creazione di una pipeline con funzioni decorate con `@step`
Puoi creare una pipeline convertendo le funzioni Python in fasi della pipeline con il decoratore `@step`, creando dipendenze tra tali funzioni per creare un grafo di pipeline (o un grafo aciclico orientato, DAG) e passando i nodi foglia del grafo come elenco di fasi alla pipeline. Le sezioni seguenti spiegano questa procedura in dettaglio con esempi.
**Topics**
+ [Conversione di una funzione in una fase](#pipelines-step-decorator-run-pipeline-convert)
+ [Creazione di dipendenze tra le fasi](#pipelines-step-decorator-run-pipeline-link)
+ [Utilizzo di `ConditionStep` con fasi decorate con `@step`](#pipelines-step-decorator-condition)
+ [Definizione di una pipeline con l’output `DelayedReturn` delle fasi](#pipelines-step-define-delayed)
+ [Crea una pipeline](#pipelines-step-decorator-pipeline-create)
## Conversione di una funzione in una fase
Per creare una fase con il decoratore `@step`, annota la funzione con `@step`. L’esempio seguente mostra una funzione decorata con `@step` che pre-elabora i dati.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
step_process_result = preprocess(raw_data)
```
Quando richiami una funzione `@step` -decorated, SageMaker AI restituisce un'`DelayedReturn`istanza invece di eseguire la funzione. Un’istanza `DelayedReturn` è un proxy per la restituzione effettiva della funzione. L’istanza `DelayedReturn` può essere passata a un’altra funzione come argomento o direttamente a un’istanza di pipeline come fase. [Per informazioni sulla `DelayedReturn` classe, vedete sagemaker.workflow.function\$1step. DelayedReturn](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.DelayedReturn).
## Creazione di dipendenze tra le fasi
Quando crei una dipendenza tra due fasi, crei una connessione tra le fasi nel grafo della pipeline. Le sezioni seguenti introducono diversi modi per creare una dipendenza tra le fasi della pipeline.
### Dipendenze dei dati tramite argomenti di input
Il passaggio nell’output `DelayedReturn` di una funzione come input in un’altra funzione crea automaticamente una dipendenza dei dati nel DAG della pipeline. Nell’esempio seguente, il passaggio dell’output `DelayedReturn` della funzione `preprocess` alla funzione `train` crea una dipendenza tra `preprocess` e `train`.
```
from sagemaker.workflow.function_step import step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
@step
def train(training_data):
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train(step_process_result)
```
L’esempio precedente definisce una funzione di addestramento decorata con `@step`. Quando questa funzione viene invocata, riceve come input l’output `DelayedReturn` della fase della pipeline di pre-elaborazione. L’invocazione della funzione di addestramento restituisce un’altra istanza `DelayedReturn`. Questa istanza contiene le informazioni su tutti le fasi precedenti definite in quella funzione (ad esempio, la fase `preprocess` in questo esempio) che formano il DAG della pipeline.
Nell’esempio precedente, la funzione `preprocess` restituisce un valore singolo. Per tipi di restituzione più complessi come elenchi o tuple, consulta [Limitazioni](pipelines-step-decorator-limit.md)
### Definizione delle dipendenze personalizzate
Nell’esempio precedente, la funzione `train` ha ricevuto l’output `DelayedReturn` di `preprocess` e ha creato una dipendenza. Se desideri definire la dipendenza in modo esplicito senza passare l’output della fase precedente, utilizza la funzione `add_depends_on` con la fase. Puoi utilizzare la funzione `get_step()` per recuperare la fase sottostante dalla relativa istanza `DelayedReturn` e quindi chiamare `add_depends_on` con la dipendenza come input. Per visualizzare la definizione della funzione `get_step()`, consulta [sagemaker.workflow.step\$1outputs.get\$1step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_outputs.get_step). L’esempio seguente mostra come creare una dipendenza tra `preprocess` e `train` utilizzando `get_step()` e`add_depends_on()`.
```
from sagemaker.workflow.step_outputs import get_step
@step
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
processed_data = ..
return s3.upload(processed_data)
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_process_result = preprocess(raw_data)
step_train_result = train()
get_step(step_train_result).add_depends_on([step_process_result])
```
### Passaggio dei dati da e verso una funzione decorata con `@step` in una fase della pipeline tradizionale
Puoi creare una pipeline che include una fase decorata con `@step` e una fase della pipeline tradizionale e trasferire i dati tra le fasi. Ad esempio, puoi utilizzare per `ProcessingStep` elaborare i dati e passare il risultato alla funzione di addestramento decorata con `@step`. Nell’esempio seguente, una fase di addestramento decorata con `@step` fa riferimento all’output di una fase di elaborazione.
```
# Define processing step
from sagemaker.sklearn.processing import SKLearnProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep
sklearn_processor = SKLearnProcessor(
framework_version='1.2-1',
role='arn:aws:iam::123456789012:role/SagemakerExecutionRole',
instance_type='ml.m5.large',
instance_count='1',
)
inputs = [
ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
]
outputs = [
ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
ProcessingOutput(output_name="test", source="/opt/ml/processing/test")
]
process_step = ProcessingStep(
name="MyProcessStep",
step_args=sklearn_processor.run(inputs=inputs, outputs=outputs,code='preprocessing.py'),
)
```
```
# Define a @step-decorated train step which references the
# output of a processing step
@step
def train(train_data_path, test_data_path):
...
return trained_model
step_train_result = train(
process_step.properties.ProcessingOutputConfig.Outputs["train"].S3Output.S3Uri,
process_step.properties.ProcessingOutputConfig.Outputs["test"].S3Output.S3Uri,
)
```
## Utilizzo di `ConditionStep` con fasi decorate con `@step`
Pipelines supporta una classe `ConditionStep` che valuta i risultati delle fasi precedenti per decidere quali azioni intraprendere nella pipeline. Puoi utilizzare `ConditionStep` anche con una fase decorata con `@step`. Per utilizzare l’output di qualsiasi fase decorata con `@step` con `ConditionStep`, inserisci l’output della fase come argomento in `ConditionStep`. Nell’esempio seguente, la fase di condizione riceve l’output della fase di valutazione del modello decorata con `@step`.
```
# Define steps
@step(name="evaluate")
def evaluate_model():
# code to evaluate the model
return {
"rmse":rmse_value
}
@step(name="register")
def register_model():
# code to register the model
...
```
```
# Define ConditionStep
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.conditions import ConditionGreaterThanOrEqualTo
from sagemaker.workflow.fail_step import FailStep
conditionally_register = ConditionStep(
name="conditional_register",
conditions=[
ConditionGreaterThanOrEqualTo(
# Output of the evaluate step must be json serializable
left=evaluate_model()["rmse"], #
right=5,
)
],
if_steps=[FailStep(name="Fail", error_message="Model performance is not good enough")],
else_steps=[register_model()],
)
```
## Definizione di una pipeline con l’output `DelayedReturn` delle fasi
Definisci una pipeline allo stesso modo, indipendentemente dal fatto che utilizzi o meno un decoratore `@step`. Quando passi un’istanza `DelayedReturn` alla pipeline, non è necessario passare un elenco completo di fasi per creare la pipeline. L’SDK deduce automaticamente le fasi precedenti in base alle dipendenze definite. Tutte le fasi precedenti degli oggetti `Step` passati alla pipeline o agli oggetti `DelayedReturn` sono incluse nel grafo della pipeline. Nell’esempio seguente, la pipeline riceve l’oggetto `DelayedReturn` per la funzione `train`. SageMaker L'intelligenza artificiale aggiunge il `preprocess` passaggio, come passaggio precedente di`train`, al grafico della pipeline.
```
from sagemaker.workflow.pipeline import Pipeline
pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=,
)
```
Se non ci sono dati o dipendenze personalizzate tra le fasi e si eseguono più fasi in parallelo, il grafo della pipeline ha più di un nodo foglia. Passa tutti questi nodi foglia in un elenco all’argomento `steps` nella definizione della pipeline, come mostrato nell’esempio seguente:
```
@step
def process1():
...
return data
@step
def process2():
...
return data
step_process1_result = process1()
step_process2_result = process2()
pipeline = Pipeline(
name="",
steps=[step_process1_result, step_process2_result],
sagemaker_session=sagemaker-session,
)
```
Quando la pipeline è in esecuzione, entrambi le fasi vengono eseguite in parallelo.
Passa solo i nodi foglia del grafico alla pipeline perché contengono informazioni su tutti le fasi precedenti definite tramite dipendenze dei dati o personalizzate. Quando compila la pipeline, l' SageMaker intelligenza artificiale deduce anche tutti i passaggi successivi che formano il grafico della pipeline e aggiunge ciascuno di essi come passaggio separato alla pipeline.
## Crea una pipeline
Crea una pipeline chiamando `pipeline.create()`, come mostrato nel frammento seguente. Per ulteriori informazioni su `create()`, consulta [sagemaker.workflow.pipeline.Pipeline.create](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.create).
```
role = "pipeline-role"
pipeline.create(role)
```
Quando chiami`pipeline.create()`, l' SageMaker IA compila tutti i passaggi definiti come parte dell'istanza della pipeline. SageMaker L'intelligenza artificiale carica la funzione serializzata, gli argomenti e tutti gli altri artefatti relativi ai passaggi su Amazon S3.
I dati risiedono nel bucket S3 in base alla seguente struttura:
```
s3_root_uri/
pipeline_name/
sm_rf_user_ws/
workspace.zip # archive of the current working directory (workdir)
step_name/
timestamp/
arguments/ # serialized function arguments
function/ # serialized function
pre_train_dependencies/ # any dependencies and pre_execution scripts provided for the step
execution_id/
step_name/
results # returned output from the serialized function including the model
```
`s3_root_uri`è definito nel file di configurazione SageMaker AI e si applica all'intera pipeline. Se non definito, viene utilizzato il bucket SageMaker AI predefinito.
**Nota**
Ogni volta che l' SageMaker intelligenza artificiale compila una pipeline, l' SageMaker intelligenza artificiale salva le funzioni, gli argomenti e le dipendenze serializzati dei passaggi in una cartella con l'ora corrente. Questo si verifica ogni volta che esegui `pipeline.create()`, `pipeline.update()`, `pipeline.upsert()` o `pipeline.definition()`.
# Esecuzione di una pipeline
La pagina seguente descrive come eseguire una pipeline con Amazon SageMaker Pipelines, con risorse SageMaker AI o localmente.
Avvia una nuova pipeline con la `pipeline.start()` funzione come faresti per l'esecuzione di una pipeline SageMaker AI tradizionale. Per informazioni sulla funzione `start()`, consulta [sagemaker.workflow.pipeline.Pipeline.start](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.start).
**Nota**
Una fase definita con il decoratore `@step` viene eseguita come job di addestramento. Pertanto, tieni presente le limitazioni seguenti:
Limiti relativi alle istanze e ai job di addestramento nei tuoi account. Aggiorna i limiti di conseguenza per evitare problemi di limitazione della larghezza di banda della rete o delle risorse.
I costi monetari associati a ogni esecuzione di una fase di addestramento nella pipeline. Per maggiori dettagli, consulta la pagina [ SageMaker dei prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/).
## Recupero dei risultati da una pipeline eseguita localmente
Per visualizzare il risultato di qualsiasi fase dell’esecuzione di una pipeline, utilizza [execution.result ()](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline._PipelineExecution.result ), come mostrato nel seguente frammento:
```
execution = pipeline.start()
execution.result(step_name="train")
```
**Nota**
Pipelines non supporta `execution.result()` in modalità locale.
Puoi recuperare i risultati di una sola fase alla volta. Se il nome della fase è stato generato dall' SageMaker intelligenza artificiale, puoi recuperarlo chiamando `list_steps` come segue:
```
execution.list_step()
```
## Esecuzione di una pipeline in locale
Puoi eseguire localmente una pipeline con fasi decorate con `@step` con la stessa modalità utilizzata per le fasi della pipeline tradizionali. Per informazioni dettagliate sull’esecuzione della pipeline in modalità locale, consulta [Esecuzione delle pipeline con la modalità locale](pipelines-local-mode.md). Per utilizzare la modalità locale, inserisci `LocalPipelineSession` invece di `SageMakerSession` nella definizione della pipeline, come illustrato nell’esempio seguente:
```
from sagemaker.workflow.function_step import step
from sagemaker.workflow.pipeline import Pipeline
from sagemaker.workflow.pipeline_context import LocalPipelineSession
@step
def train():
training_data = s3.download(....)
...
return trained_model
step_train_result = train()
local_pipeline_session = LocalPipelineSession()
local_pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=local_pipeline_session # needed for local mode
)
local_pipeline.create(role_arn="role_arn")
# pipeline runs locally
execution = local_pipeline.start()
```
# Configurazione della pipeline
Si consiglia di utilizzare il file di configurazione SageMaker AI per impostare i valori predefiniti per la pipeline. Per informazioni sul file di configurazione SageMaker AI, consulta [Configurazione e utilizzo dei valori predefiniti con Python SageMaker SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#configuring-and-using-defaults-with-the-sagemaker-python-sdk). Qualsiasi configurazione aggiunta al file di configurazione si applica a tutte le fasi della pipeline. Per sostituire le opzioni di una qualsiasi fase, fornisci nuovi valori negli argomenti decoratore `@step`. L’argomento seguente descrive come impostare un file di configurazione.
La configurazione del decoratore `@step` nel file di configurazione è identica a quella del decoratore `@remote`. Per impostare l’ARN del ruolo della pipeline e i tag della pipeline nel file di configurazione, utilizza la sezione `Pipeline` mostrata nel seguente frammento:
```
SchemaVersion: '1.0'
SageMaker:
Pipeline:
RoleArn: 'arn:aws:iam::555555555555:role/IMRole'
Tags:
- Key: 'tag_key'
Value: 'tag_value'
```
Per la maggior parte delle impostazioni predefinite nel file di configurazione, puoi eseguire la sostituzione anche passando nuovi valori al decoratore `@step`. Ad esempio, puoi sostituire il tipo di istanza impostato nel file di configurazione per la fase di pre-elaborazione, come illustrato nell’esempio seguente:
```
@step(instance_type="ml.m5.large")
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
```
Alcuni argomenti non fanno parte dell'elenco dei parametri del `@step` decoratore: possono essere configurati per l'intera pipeline solo tramite il file di configurazione AI. SageMaker Sono elencati qui di seguito:
+ `sagemaker_session`(`sagemaker.session.Session`): La sessione SageMaker AI sottostante a cui l'IA delega le chiamate di servizio SageMaker . Se non è specificata, viene creata una sessione con una configurazione predefinita come descritto di seguito:
```
SageMaker:
PythonSDK:
Modules:
Session:
DefaultS3Bucket: 'default_s3_bucket'
DefaultS3ObjectKeyPrefix: 'key_prefix'
```
+ `custom_file_filter` (`CustomFileFilter)`: un oggetto `CustomFileFilter` che specifica le directory e i file locali da includere nella fase della pipeline. Se non è specificato, il valore predefinito è `None`. Affinché `custom_file_filter` abbia effetto, è necessario impostare `IncludeLocalWorkdir` su `True`. L’esempio seguente mostra una configurazione che ignora tutti i file del notebook, nonché i file e le directory denominati `data`.
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
IncludeLocalWorkDir: true
CustomFileFilter:
IgnoreNamePatterns: # files or directories to ignore
- "*.ipynb" # all notebook files
- "data" # folder or file named "data"
```
Per ulteriori dettagli su come utilizzare `IncludeLocalWorkdir` con `CustomFileFilter`, consulta [Utilizzo del codice modulare con il decoratore @remote](train-remote-decorator-modular.md).
+ `s3_root_uri (str)`: La cartella principale di Amazon S3 in cui SageMaker AI carica gli archivi e i dati del codice. Se non specificato, viene utilizzato il bucket SageMaker AI predefinito.
+ `s3_kms_key (str)`: la chiave utilizzata per crittografare i dati di input e output. È possibile configurare questo argomento solo nel file di configurazione SageMaker AI e l'argomento si applica a tutti i passaggi definiti nella pipeline. Se non specificato, il valore predefinito è `None`. Vedi il frammento seguente per un esempio di configurazione della chiave S3 KMS:
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
S3KmsKeyId: 's3kmskeyid'
S3RootUri: 's3://amzn-s3-demo-bucket/my-project
```
# Best practice
Le sezioni seguenti suggeriscono le best practice da seguire quando utilizzi il decoratore `@step` per le fasi della pipeline.
## Utilizzo dei warm pool
Per velocizzare l’esecuzione delle fasi della pipeline, utilizza la funzionalità warm pool fornita per i job di addestramento. Puoi attivare la funzionalità warm pool fornendo l’argomento `keep_alive_period_in_seconds` al decoratore `@step`, come illustrato nel frammento seguente:
```
@step(
keep_alive_period_in_seconds=900
)
```
Per ulteriori informazioni sui warm pool, consulta [SageMaker Piscine calde gestite dall'IA](train-warm-pools.md).
## Struttura della directory
Consigliamo di utilizzare moduli di codice quando lavori con il decoratore `@step`. Inserisci il modulo `pipeline.py`, nel quale vengono invocate le funzioni della fase e viene definita la pipeline, nella root dello spazio di lavoro. La struttura consigliata viene mostrata di seguito:
```
.
├── config.yaml # the configuration file that define the infra settings
├── requirements.txt # dependencies
├── pipeline.py # invoke @step-decorated functions and define the pipeline here
├── steps/
| ├── processing.py
| ├── train.py
├── data/
├── test/
```
# Limitazioni
Le sezioni seguenti descrivono le limitazioni da tenere presenti quando utilizzi il decoratore `@step` per le fasi della pipeline.
## Limitazioni degli argomenti delle funzioni
Quando passi un argomento di input alla funzione decorata con `@step`, si applicano le seguenti limitazioni:
+ Puoi passare come argomenti gli oggetti `DelayedReturn`, `Properties` (di altri tipi di fasi), `Parameter` e `ExecutionVariable` alle funzioni decorate con `@step`. Tuttavia, le funzioni decorate con `@step` non supportano gli oggetti `JsonGet` e `Join` come argomenti.
+ Non puoi accedere direttamente a una variabile della pipeline da una funzione `@step`. L’esempio seguente genera un errore:
```
param = ParameterInteger(name="", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ Non puoi annidare una variabile della pipeline in un altro oggetto e passarla a una funzione `@step`. L’esempio seguente genera un errore:
```
param = ParameterInteger(name="", default_value=10)
@step
def func(arg):
print(arg)
func(arg=(param,)) # this raises a SerializationError because param is nested in a tuple
```
+ Poiché gli input e gli output di una funzione sono serializzati, esistono limitazioni sui tipi di dati che possono essere passati come input o output da una funzione. Per maggiori dettagli, consulta la sezione *Serializzazione e deserializzazione dei dati* di [Invocare una funzione remota](train-remote-decorator-invocation.md). Le stesse limitazioni si applicano alle funzioni decorate con `@step`.
+ Tutti gli oggetti con un client boto non possono essere serializzati, quindi non puoi passare tali oggetti come input o output da una funzione decorata con `@step`. Ad esempio, le classi client SageMaker Python SDK come `Estimator``Predictor`, e non `Processor` possono essere serializzate.
## Importazioni di funzioni
Devi importare le librerie richieste dalla fase all’interno e non all’esterno della funzione. Se le importi a livello globale, rischi un conflitto di importazione durante la serializzazione della funzione. Ad esempio, `sklearn.pipeline.Pipeline` potrebbe essere sovrascritto da `sagemaker.workflow.pipeline.Pipeline`.
## Riferimento ai membri secondari del valore restituito dalla funzione
Se fai riferimento ai membri secondari di un valore restituito dalla funzione decorata con `@step`, si applicano le seguenti limitazioni:
+ Puoi fare riferimento ai membri secondari utilizzando `[]` se l’oggetto `DelayedReturn` rappresenta una tupla, un elenco o un dict, come mostrato nell’esempio seguente:
```
delayed_return[0]
delayed_return["a_key"]
delayed_return[1]["a_key"]
```
+ Non puoi decomprimere l’output di una tupla o di un elenco perché la lunghezza esatta della tupla o dell’elenco sottostante non può essere nota quando invochi la funzione. L’esempio seguente genera un errore:
```
a, b, c = func() # this raises ValueError
```
+ Non puoi eseguire iterazioni su un oggetto `DelayedReturn`. L’esempio seguente genera un errore:
```
for item in func(): # this raises a NotImplementedError
```
+ Non è possibile fare riferimento ai membri secondari arbitrari con “`.`”. L’esempio seguente genera un errore:
```
delayed_return.a_child # raises AttributeError
```
## Funzionalità delle pipeline esistenti che non sono supportate
Non è possibile utilizzare il decoratore `@step` con le funzionalità della pipeline seguenti:
+ [Caching delle fasi della pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-caching.html)
+ [File delle proprietà](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html#build-and-manage-propertyfile-property)
# Passaggio dei dati tra le fasi
Quando crei pipeline con Amazon SageMaker Pipelines, potresti dover passare i dati da una fase all'altra. Ad esempio, potresti voler utilizzare gli artefatti del modello generati da una fase di addestramento come input per una fase di valutazione o implementazione del modello. Puoi utilizzare questa funzionalità per creare fasi della pipeline interdipendenti e flussi di lavoro di ML.
Quando devi recuperare informazioni dall’output di una fase della pipeline, puoi utilizzare `JsonGet`. `JsonGet` ti aiuta a estrarre informazioni da Amazon S3 o dai file delle proprietà. Le sezioni seguenti spiegano i metodi con cui estrarre gli output delle fasi con `JsonGet`.
## Passaggio dei dati tra le fasi con Amazon S3
Puoi utilizzare `JsonGet` in `ConditionStep` per recuperare l’output JSON direttamente da Amazon S3. L’URI di Amazon S3 può essere una funzione `Std:Join` che contiene stringhe primitive, variabili di esecuzione della pipeline o parametri della pipeline. L’esempio seguente mostra come utilizzare `JsonGet` in `ConditionStep`.
```
# Example json file in s3 bucket generated by a processing_step
{
"Output": [5, 10]
}
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name="",
s3_uri="",
json_path="Output[1]"
),
right=6.0
)
```
Se utilizzi `JsonGet` con un percorso Amazon S3 nella fase di condizione, devi aggiungere esplicitamente una dipendenza tra la fase di condizione e la fase che genera l’output JSON. Nell’esempio seguente, la fase di condizione viene creata con una dipendenza dalla fase di elaborazione:
```
cond_step = ConditionStep(
name="",
conditions=[cond_lte],
if_steps=[fail_step],
else_steps=[register_model_step],
depends_on=[processing_step],
)
```
## Passaggio dei dati tra le fasi con file delle proprietà
Utilizza i file di proprietà per archiviare informazioni dall'output di una fase di elaborazione. Ciò è particolarmente utile quando si analizzano i risultati di una fase di elaborazione per decidere come eseguire una fase condizionale. La `JsonGet` funzione elabora un file di proprietà e consente di utilizzare la JsonPath notazione per interrogare il file JSON della proprietà. [Per ulteriori informazioni sulla JsonPath notazione, consulta il repository. JsonPath ](https://github.com/json-path/JsonPath)
Per archiviare un file di proprietà per un uso successivo, devi prima creare un'istanza `PropertyFile` con il seguente formato. Il parametro `path` è il nome del file JSON in cui viene salvato il file di proprietà. Qualsiasi `output_name` deve corrispondere al `output_name` del `ProcessingOutput` definito nella fase di elaborazione. Ciò consente al file di proprietà di acquisire `ProcessingOutput` durante la fase.
```
from sagemaker.workflow.properties import PropertyFile
= PropertyFile(
name="",
output_name="",
path=""
)
```
Quando crei l'`ProcessingStep`istanza, aggiungi il `property_files` parametro per elencare tutti i file di parametri che il servizio Amazon SageMaker Pipelines deve indicizzare. In questo modo il file di proprietà viene salvato per un uso successivo.
```
property_files=[]
```
Per utilizzare il file di proprietà in una fase condizionale, aggiungi `property_file` alla condizione che passi alla fase condizionale, come illustrato nell'esempio seguente, per eseguire query sul file JSON per la proprietà desiderata utilizzando il parametro `json_path`.
```
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=,
json_path="mse"
),
right=6.0
)
```
Per esempi più approfonditi, consulta *[Property File](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#property-file)* nell'SDK [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Caching delle fasi della pipeline
In Amazon SageMaker Pipelines, puoi utilizzare la memorizzazione nella cache degli step per risparmiare tempo e risorse durante la riesecuzione delle pipeline. Il caching delle fasi riutilizza l’output dell’esecuzione di una fase precedente riuscita (invece di ricalcolarlo) quando la fase ha la stessa configurazione e gli stessi input. Questo consente di ottenere risultati coerenti tra le riesecuzioni di pipeline con parametri identici. L’argomento seguente mostra come configurare e attivare il caching delle fasi per le pipeline.
Quando utilizzi il caching delle firme delle fasi, Pipelines cerca di trovare un’esecuzione precedente della fase corrente della pipeline con gli stessi valori per determinati attributi. Se la trova, Pipelines propaga gli output dell’esecuzione precedente anziché ricalcolare la fase. Gli attributi controllati sono specifici del tipo di fase e sono elencati in [Attributi chiave della cache predefiniti per tipo di fase della pipeline](pipelines-default-keys.md).
È necessario attivare la memorizzazione nella cache delle fasi: per impostazione predefinita è disattivata. Quando attivi la memorizzazione nella cache delle fasi, devi anche definire un timeout. Questo timeout definisce quanto tempo può essere passato dall'esecuzione precedente perché questa rimanga utilizzabile.
La memorizzazione nella cache delle fasi considera solo le esecuzioni riuscite e non riutilizza mai le esecuzioni non riuscite. Se esistono più esecuzioni riuscite prima del timeout, Pipelines utilizza il risultato dell’esecuzione riuscita più recente. Se non viene trovata alcuna esecuzione riuscita prima del timeout, Pipelines esegue nuovamente la fase. Se l'executor trova un'esecuzione precedente che soddisfa i criteri ma è ancora in corso, entrambe le fasi continuano a essere eseguite e aggiorna la cache se hanno esito positivo.
La memorizzazione nella cache delle fasi è riservata solo alle singole pipeline, quindi non è possibile riutilizzare una fase di un'altra pipeline anche se la firma delle fasi corrisponde.
La memorizzazione nella cache delle fasi è disponibile per i seguenti tipi di fase:
+ [Processing](build-and-manage-steps-types.md#step-type-processing)
+ [Addestramento](build-and-manage-steps-types.md#step-type-training)
+ [Ottimizzazione](build-and-manage-steps-types.md#step-type-tuning)
+ [AutoML](build-and-manage-steps-types.md#step-type-automl)
+ [Trasformazione](build-and-manage-steps-types.md#step-type-transform)
+ [`ClarifyCheck`](build-and-manage-steps-types.md#step-type-clarify-check)
+ [`QualityCheck`](build-and-manage-steps-types.md#step-type-quality-check)
+ [EMR](build-and-manage-steps-types.md#step-type-emr)
**Topics**
+ [Attivazione della memorizzazione nella cache delle fasi](pipelines-caching-enabling.md)
+ [Disattivazione della memorizzazione nella cache delle fasi](pipelines-caching-disabling.md)
+ [Attributi chiave della cache predefiniti per tipo di fase della pipeline](pipelines-default-keys.md)
+ [Controllo dell'accesso ai dati nella cache](pipelines-access-control.md)
# Attivazione della memorizzazione nella cache delle fasi
Per attivare il caching delle fasi, devi aggiungere una proprietà `CacheConfig` alla definizione della fase. Le proprietà `CacheConfig` utilizzano il seguente formato nel file di definizione della pipeline:
```
{
"CacheConfig": {
"Enabled": false,
"ExpireAfter": "