翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# SageMaker AI ワークフロー
機械学習 (ML) の運用をスケールする際、Amazon SageMaker AI のフルマネージドワークフローサービスを使用して、ML ライフサイクルの継続的インテグレーションと継続的デプロイ (CI/CD) を実践できます。Pipelines SDK を使用すると、パイプラインのステップを選択して統合ソリューションに統合し、データの準備からモデルのデプロイまでのモデル構築プロセスを自動化できます。Kubernetes ベースのアーキテクチャの場合、Kubernetes クラスターに SageMaker AI 演算子をインストールし、Kubernetes API や `kubectl` などのコマンドライン Kubernetes ツールを使用して SageMaker AI ジョブをネイティブに作成できます。Kubeflow パイプライン用の SageMaker AI コンポーネントを使用すると、Kubeflow Pipelines から SageMaker AI のネイティブジョブを作成してモニタリングできます。SageMaker AI のジョブパラメータ、ステータス、出力には、Kubeflow パイプライン UI からアクセスできます。最後に、バッチジョブをスケジュールする場合は、 AWS Batch ジョブキュー統合または Jupyter ノートブックベースのワークフローサービスのいずれかを使用して、定義したスケジュールでスタンドアロンまたは定期的な実行を開始できます。
要約すると、SageMaker AI は以下のワークフロー技術を提供します。
+ [Pipelines](pipelines.md): ML パイプラインを構築して管理するためのツール。
+ [Kubernetes のオーケストレーション](kubernetes-workflows.md): Kubernetes クラスター用の SageMaker AI カスタム演算子と Kubeflow Pipelines のコンポーネント
+ [SageMaker ノートブックジョブ](notebook-auto-run.md): Jupyter Notebook のオンデマンドまたはスケジュール済み非インタラクティブなバッチ実行。
SageMaker AI と統合されている他のサービスを活用してワークフローを構築することもできます。オプションには次のサービスが含まれます。
+ [Airflow ワークフロー](https://sagemaker.readthedocs.io/en/stable/workflows/airflow/index.html): Airflow ワークフローを作成および管理するための設定をエクスポートする SageMaker API。
+ [AWS Step Functions](https://sagemaker.readthedocs.io/en/stable/workflows/step_functions/index.html): リソースを個別にプロビジョンする必要なく、SageMaker AI インフラストラクチャをオーケストレーションする Python のマルチステップ ML ワークフロー
+ [AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/getting-started-sagemaker.html): SageMaker AI トレーニングジョブを AWS Batch ジョブキューに送信します。ジョブキューでは、コンピューティング環境で実行するジョブを優先してスケジュールできます。
SageMaker トレーニングと推論の管理の詳細については、「[Amazon SageMaker Python SDK ワークフロー](https://sagemaker.readthedocs.io/en/stable/workflows/index.html)」を参照してください。
**Topics**
+ [Pipelines](pipelines.md)
+ [Kubernetes のオーケストレーション](kubernetes-workflows.md)
+ [SageMaker ノートブックジョブ](notebook-auto-run.md)
+ [ML ワークフローをスケジュールする](workflow-scheduling.md)
+ [AWS Batch SageMaker AI トレーニングジョブのサポート](training-job-queues.md)
# Pipelines
Amazon SageMaker Pipelines は、機械学習 (ML) 開発の自動化専用のワークフローオーケストレーションサービスです。
Pipelines には、他の AWS ワークフロー製品よりも以下の利点があります。
**自動スケーリングサーバーレスインフラストラクチャ** Pipelines の実行のために基盤となるオーケストレーションインフラストラクチャを管理する必要がないため、コアの ML タスクに集中できます。SageMaker AI は、ML ワークロードのニーズに応じて、パイプラインオーケストレーションコンピューティングリソースを自動的にプロビジョン、スケール、シャットダウンします。
**直感的なユーザーエクスペリエンス** Pipelines は、ビジュアルエディタ、SDK、API、JSON のいずれかのインターフェイスを使用して作成および管理を行うことができます。Amazon SageMaker Studio ビジュアルインターフェイスで、さまざまな ML ステップをドラッグアンドドロップしてパイプラインを作成できます。以下のスクリーンショットは、パイプラインのための Studio ビジュアルエディタを示しています。
![\[Studio の Pipelines のビジュアルドラッグアンドドロップインターフェイスのスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/pipelines/pipelines-studio-overview.png)
ML ワークフローをプログラムで管理する場合、SageMaker Python SDK は高度なオーケストレーション機能を提供しています。詳細については、「SageMaker Python SDK ドキュメント」の「[Amazon SageMaker Pipelines](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html)」を参照してください。
**AWS 統合** Pipelines は、データ処理、モデルトレーニング、ファインチューニング、評価、デプロイ、モニタリングジョブを自動化するために、すべての SageMaker AI 機能やその他の AWS サービスとシームレスに統合します。SageMaker AI 機能をパイプラインに組み込み、ディープリンクを使用して複数のパイプラインにわたって操作し、大規模な ML ワークフローを作成、モニタリング、デバッグできます。
**コスト削減** Pipelines では、SageMaker Studio 環境と Pipelines がオーケストレーションを行う基盤となるジョブ (SageMaker Training、SageMaker Processing、SageMaker Inference、Amazon S3 データストレージなど) に対してのみ料金が発生します。
**監査可能性とリネージトラッキング** Pipelines では、組み込みのバージョニングを使用して、パイプラインの更新と実行の履歴を追跡できます。Amazon SageMaker ML Lineage Tracking は、エンドツーエンドの ML 開発ライフサイクルにおけるデータソースとデータコンシューマーの分析に役立ちます。
**Topics**
+ [Pipelines の概要](pipelines-overview.md)
+ [Pipelines のアクション](pipelines-build.md)
# Pipelines の概要
Amazon SageMaker パイプラインは、ドラッグアンドドロップ UI または [Pipelines SDK](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html) を使用して定義される、有向非巡回グラフ (DAG) 内の相互接続されたステップのセットです。[パイプライン定義 JSON スキーマ](https://aws-sagemaker-mlops.github.io/sagemaker-model-building-pipeline-definition-JSON-schema/)を使用してパイプラインを構築することもできます。この DAG の JSON 定義は、パイプラインの各ステップの要件と関係性に関する情報を提供します。パイプラインの DAG の構造は、ステップ間のデータの依存関係によって決まります。これらのデータ依存関係は、ステップの出力のプロパティが別のステップに入力として渡される際に作成されます。次の図は、パイプライン DAG の例です。
![\[\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/pipeline-full.png)
**この例の DAG には以下のステップが含まれます。**
1. `AbaloneProcess` は、[処理](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing)ステップのインスタンスで、トレーニングに使用するデータに対して前処理スクリプトを実行します。例えば、このスクリプトを使用して、欠損値の補完入力、数値データの正規化、データのトレーニング、検証、テストデータセットへの分割ができます。
1. `AbaloneTrain` は、[トレーニング](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-training)ステップのインスタンスで、ハイパーパラメータを設定し、前処理された入力データからモデルをトレーニングします。
1. `AbaloneEval` は、[処理](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-processing)ステップの別のインスタンスで、モデルの精度を評価します。このステップは、データ依存関係の一例となります。このステップでは、`AbaloneProcess` のテストデータセット出力を使用します。
1. `AbaloneMSECond` は、[条件](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-condition)ステップのインスタンスで、この例では、モデル評価の平均二乗誤差の結果が特定の制限を下回っていることを確認します。モデルが基準を満たさない場合、パイプラインの実行が停止します。
1. パイプラインの実行は、次のステップで続行します。
1. `AbaloneRegisterModel` では、SageMaker AI が [RegisterModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-register-model) ステップを呼び出して、モデルをバージョン管理されたモデルパッケージグループとして Amazon SageMaker モデルレジストリに登録します。
1. `AbaloneCreateModel` では、SageMaker AI が [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-create-model) ステップを呼び出して、バッチ変換の準備としてモデルを作成します。`AbaloneTransform` では、SageMaker AI が [Transform](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#step-type-transform) ステップを呼び出して、指定したデータセットでモデル予測を生成します。
以降のトピックでは、基本的な Pipelines の概念について説明します。これらの概念の実装を解説したチュートリアルについては、「[Pipelines のアクション](pipelines-build.md)」を参照してください。
**Topics**
+ [パイプラインの構造と実行](build-and-manage-pipeline.md)
+ [IAM アクセス管理](build-and-manage-access.md)
+ [Pipelines のクロスアカウントサポートを設定する](build-and-manage-xaccount.md)
+ [Pipeline のパラメータ](build-and-manage-parameters.md)
+ [Pipelines のステップ](build-and-manage-steps.md)
+ [@step デコレータを使用した Python コードのリフトアンドシフト](pipelines-step-decorator.md)
+ [ステップ間でデータを渡す](build-and-manage-propertyfile.md)
+ [パイプラインのステップのキャッシュ](pipelines-caching.md)
+ [パイプラインのステップの再試行ポリシー](pipelines-retry-policy.md)
+ [パイプラインステップの選択的実行](pipelines-selective-ex.md)
+ [Amazon SageMaker Pipelines の ClarifyCheck と QualityCheck のステップを使用したベースライン計算、ドリフト検出、ライフサイクル](pipelines-quality-clarify-baseline-lifecycle.md)
+ [パイプライン実行をスケジュールする](pipeline-eventbridge.md)
+ [Amazon SageMaker Experiments の統合](pipelines-experiments.md)
+ [ローカルモードを使用してパイプラインを実行する](pipelines-local-mode.md)
+ [Amazon SageMaker Pipelines のトラブルシューティング](pipelines-troubleshooting.md)
# パイプラインの構造と実行
**Topics**
+ [パイプラインの構造](#build-and-manage-pipeline-structure)
+ [並列処理設定を使用したパイプラインの実行](#build-and-manage-pipeline-execution)
## パイプラインの構造
Amazon SageMaker Pipelines インスタンスは、`name`、`parameters`、`steps` で構成されています。パイプライン名は、`(account, region)` ペア内で一意である必要があります。ステップ定義で使用されるすべてのパラメータは、パイプラインで定義する必要があります。リストされているパイプラインステップは、相互のデータ依存関係によって実行順序が自動的に決定されます。Pipelines サービスは、データ依存関係 DAG 内のステップ間の関係を解決して、実行を完了するステップのセットを作成します。以下は、パイプライン構造の例です。
**警告**
ビジュアルエディタまたは SageMaker AI Python SDK を使用してパイプラインを構築する場合、パイプラインパラメータやステップ定義フィールド (環境変数など) に機密情報を含めないでください。これらのフィールドは、将来 `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],
)
```
## 並列処理設定を使用したパイプラインの実行
デフォルトでは、パイプラインは、並列で実行できるすべてのステップを実行します。この動作は、パイプラインを作成または更新するとき、およびパイプラインの実行を開始または再試行するときに `ParallelismConfiguration` プロパティを使用して制御できます。
並列処理の設定は、実行ごとに適用されます。例えば、2 つの実行を開始して、それぞれが最大 50 ステップを同時に実行できる場合は、合計 100 ステップが同時に実行されます。また、実行の開始時、再試行時、または更新時に指定した `ParallelismConfiguration` は、パイプラインで定義した並列処理設定よりも優先されます。
**Example `ParallelismConfiguration` でパイプラインの実行を作成する**
```
pipeline = Pipeline(
name="myPipeline",
steps=[step_process, step_train]
)
pipeline.create(role, parallelism_config={"MaxParallelExecutionSteps": 50})
```
# IAM アクセス管理
以下のセクションでは、Amazon SageMaker Pipelines の AWS Identity and Access Management (IAM) 要件について説明します。これらのアクセス許可の実装例については、「[前提条件](define-pipeline.md#define-pipeline-prereq)」を参照してください。
**Topics**
+ [パイプラインロールのアクセス許可](#build-and-manage-role-permissions)
+ [パイプラインステップのアクセス許可](#build-and-manage-step-permissions)
+ [Amazon S3 バケットを使用した CORS 設定](#build-and-manage-cors-s3)
+ [Pipelines ジョブのアクセス管理をカスタマイズする](#build-and-manage-step-permissions-prefix)
+ [パイプラインバージョンへのアクセスをカスタマイズする](#build-and-manage-step-permissions-version)
+ [Pipelines を使用したサービスコントロールポリシー](#build-and-manage-scp)
## パイプラインロールのアクセス許可
パイプラインには、パイプラインの作成時に Pipelines に渡される IAM パイプライン実行ロールが必要です。パイプラインの作成に使用する SageMaker AI インスタンスのロールには、パイプライン実行ロールを指定する`iam:PassRole`アクセス許可を持つポリシーが必要です。これは、インスタンスがパイプラインの作成と実行に使用するパイプライン実行ロールを Pipelines サービスに渡すためのアクセス許可が必要なためです。IAM ロールの詳細については、「[IAM ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)」を参照してください。
パイプラインの実行ロールには、次のアクセス許可が必要です。
+ (デフォルトで使用されるパイプライン実行ロールではなく) パイプライン内の任意の SageMaker AI ジョブステップに、一意またはカスタマイズされたロールを使用できます。パイプライン実行ロールが、これらの各ロールを指定する`iam:PassRole`アクセス許可を持つポリシーを追加していることを確認します。
+ パイプライン内の各ジョブタイプに対する `Create` と `Describe` のアクセス許可。
+ `JsonGet` 関数を使用するための Amazon S3 アクセス許可。Amazon S3 リソースへのアクセスは、リソースベースのポリシーとアイデンティティベースのポリシーを使用して制御します。リソースベースのポリシーが Amazon S3 バケットに適用され、Pipelines にバケットへのアクセス権が付与されます。アイデンティティベースのポリシーは、アカウントから Amazon S3 呼び出しを行う機能をパイプラインに提供します。リソースベースのポリシーとアイデンティティベースのポリシーの詳細については、「[アイデンティティベースのポリシーとリソースベースのポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html)」を参照してください。
```
{
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::/*",
"Effect": "Allow"
}
```
## パイプラインステップのアクセス許可
Pipelines は、SageMaker AI ジョブを実行する手順を提供しています。パイプラインステップでこれらのジョブを実行するには、必要なリソースへのアクセスを提供する IAM ロールがアカウントに必要です。このロールは、パイプラインによって SageMaker AI サービスプリンシパルに渡されます。IAM ロールの詳細については、「[IAM ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)」を参照してください。
デフォルトでは、各ステップがパイプラインの実行ロールを取得します。必要に応じて、パイプラインの任意のステップに別のロールを渡すこともできます。こうすることで、パイプライン定義で指定される 2 つのステップ間に直接的な関係がない限り、各ステップのコードは他のステップで使用されるリソースに影響を与えないようになります。これらのロールは、ステップのプロセッサや推定器を定義するときに渡します。これらの定義にロールを含める方法の例については、「[SageMaker AI Python SDK ドキュメント](https://sagemaker.readthedocs.io/en/stable/overview.html#using-estimators)」を参照してください。
## Amazon S3 バケットを使用した CORS 設定
Amazon S3 バケットから Pipelines にイメージが期待どおりにインポートされるようにするには、イメージのインポート元となる Amazon S3 バケットに CORS 設定を追加する必要があります。このセクションでは、必要な CORS 設定を Amazon S3 バケットに設定する方法について説明します。Pipelines に必要な XML `CORSConfiguration` は、[入力イメージデータの CORS 要件](sms-cors-update.md) の XML とは異なります。これ以外の場合は、XML に記載されている情報を使用して、Amazon S3 バケットの CORS 要件の詳細を取得できます。
イメージをホストする Amazon S3 バケットには、次の CORS 設定コードを使用します。CORS を設定する手順については、「Amazon Simple Storage Service ユーザーガイド」の「[Cross−Origin Resource Sharing (CORS) の設定](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-cors-configuration.html)」を参照してください。Amazon S3 コンソールを使用してポリシーをバケットに追加する場合は、JSON 形式を使用する必要があります。
**JSON**
```
[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"PUT"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": [
"Access-Control-Allow-Origin"
]
}
]
```
**XML**
```
*
*
PUT
Access-Control-Allow-Origin
```
次の GIF は、Amazon S3 コンソールを使って CORS ヘッダーポリシーを追加する方法に関する Amazon S3 ドキュメントにある手順を示しています。
![\[Amazon S3 コンソールを使用して CORS ヘッダーポリシーを追加する方法を示す GIF。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/sms/gifs/cors-config.gif)
## Pipelines ジョブのアクセス管理をカスタマイズする
IAM ポリシーをさらにカスタマイズして、組織内の特定のメンバーがパイプラインステップの一部またはすべてを実行できるようにすることが可能です。例えば、特定のユーザーにトレーニングジョブを作成するアクセス許可を付与し、別のユーザーグループに処理ジョブを作成するアクセス許可を付与し、すべてのユーザーに残りのステップを実行するアクセス許可を付与できます。この機能を使用するには、ジョブ名にプレフィックスとして付けるカスタム文字列を選択します。管理者は許可された ARN の先頭にプレフィックスを付加し、データサイエンティストはこのプレフィックスをパイプラインのインスタンス化に含めます。許可されたユーザーの IAM ポリシーには、指定されたプレフィックスの付いたジョブ ARN が含まれているため、パイプラインステップの後続のジョブには、続行するために必要なアクセス許可が付与されます。ジョブプレフィックスはデフォルトではオフになっています。使用するには `Pipeline` クラスでこのオプションをオンにする必要があります。
プレフィックスがオフになっているジョブの場合、ジョブ名は次の表で説明するフィールドを連結した形式になります。
`pipelines----`
| フィールド | 定義 |
| --- | --- |
| pipelines | 常に静的な文字列が先頭に追加されます。この文字列は、パイプラインオーケストレーションサービスをジョブのソースとして識別します。 |
| executionId | 実行中のパイプラインインスタンス用のランダム化されたバッファ。 |
| stepNamePrefix | ユーザー指定のステップ名 (パイプラインステップの `name` 引数で指定)。最初の 20 文字に制限されます。 |
| entityToken | ステップエンティティが冪等性であることを保証するためのランダム化されたトークン。 |
| failureCount | ジョブを完了するために試行された現在の再試行回数。 |
この場合、ジョブ名の先頭にはカスタムプレフィックスは付けられず、対応する IAM ポリシーがこの文字列と一致する必要があります。
ジョブプレフィックスを有効にするユーザーの場合、基になるジョブ名は次の形式になり、カスタムプレフィックスは `MyBaseJobName` として指定されます。
**-**-**-**
カスタムプレフィックスは、静的な `pipelines` 文字列を置き換え、パイプラインの一部として SageMaker AI ジョブを実行できるユーザーの選択を絞り込むのに役立ちます。
**プレフィックスの長さ制限**
ジョブ名には、個々のパイプラインステップに固有の内部の長さ制限があります。この制約により、許可されるプレフィックスの長さも制限されます。プレフィックスの長さの要件は以下のとおりです。
| パイプラインのステップ | プレフィックスの長さ |
| --- | --- |
| `[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 |
### IAM ポリシーにジョブプレフィックスを適用する
管理者は IAM ポリシーを作成して、特定のプレフィックスを持つユーザーにジョブの作成を許可します。以下のポリシーの例では、データサイエンティストに、`MyBaseJobName` プレフィックスを使用する場合にトレーニングジョブの作成を許可しています。
```
{
"Action": "sagemaker:CreateTrainingJob",
"Effect": "Allow",
"Resource": [
"arn:aws:sagemaker:region:account-id:*/MyBaseJobName-*"
]
}
```
### ジョブプレフィックスをパイプラインインスタンス化に適用する
プレフィックスをジョブインスタンスクラスの `*base_job_name` 引数で指定します。
**注記**
パイプラインステップを作成する前に、`*base_job_name` 引数付きのジョブプレフィックスをジョブインスタンスに渡します。このジョブインスタンスには、ジョブをパイプラインのステップとして実行するのに必要な情報が含まれています。この引数は、使用するジョブインスタンスによって異なります。次のリストは、各パイプラインステップタイプにどの引数を使用するかを示しています。
`[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)`)、`[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)`) クラス用の `base_job_name`
`[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)`) 用の `tuning_base_job_name`
`[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)`) 用の `transform_base_job_name`
`[QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#qualitycheckstep)` (品質チェック) クラスと `[ClarifyCheckstep](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#clarifycheckstep)` (明確化チェック) クラス用の `[CheckJobConfig](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#checkjobconfig)` の `base_job_name`
`[Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html)` クラスに使用される引数は、結果を `[ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#step-collections)` に渡す前にモデルに対して `create` を実行するか `register` を実行するかによって異なります。
`create` を呼び出す場合、カスタムプレフィックスはモデルを構築するときの `name` 引数から取得されます (つまり `Model(name=)`)。
`register` を呼び出す場合、カスタムプレフィックスは `register` 呼び出しの `model_package_name` 引数から取得されます (つまり `my_model.register(model_package_name=)`)
次の例は、新しいトレーニングジョブインスタンスのプレフィックスを指定する方法を示しています。
```
# 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(...)
}
)
```
ジョブプレフィックスはデフォルトではオフになっています。この機能を有効にするには、以下のスニペットに示す `PipelineDefinitionConfig` の `use_custom_job_prefix` オプションを使用します。
```
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
)
```
パイプラインを作成して実行します。次の例では、パイプラインを作成して実行し、ジョブのプレフィックスをオフにしてパイプラインを再実行する方法も示しています。
```
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()
```
同様に、既存のパイプラインでもこの機能をオンに切り替えて、ジョブプレフィックスを使用する新規の実行を開始できます。
```
definition_config = PipelineDefinitionConfig(use_custom_job_prefix=True)
pipeline.pipeline_definition_config = definition_config
pipeline.update()
execution = pipeline.start()
```
最後に、パイプライン実行時に `list_steps` を呼び出して、カスタムプレフィックスが付いたジョブを表示できます。
```
steps = execution.list_steps()
prefixed_training_job_name = steps['PipelineExecutionSteps'][0]['Metadata']['TrainingJob']['Arn']
```
## パイプラインバージョンへのアクセスをカスタマイズする
`sagemaker:PipelineVersionId` 条件キーを使用して、特定のバージョンの Amazon SageMaker Pipelines へのカスタマイズされたアクセスを許可できます。例えば、以下のポリシーは、バージョン ID 6 以降にたいしてのみ、実行を開始したり、パイプラインバージョンを更新したりするためのアクセスを許可します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowStartPipelineExecution",
"Effect": "Allow",
"Action": [
"sagemaker:StartPipelineExecution",
"sagemaker:UpdatePipelineVersion"
],
"Resource": "*",
"Condition": {
"NumericGreaterThanEquals": {
"sagemaker:PipelineVersionId": 6
}
}
}
}
```
------
サポートされる条件キーの詳細については、「[Amazon SageMaker AI の条件キー](https://docs.aws.amazon.com//service-authorization/latest/reference/list_amazonsagemaker.html#amazonsagemaker-policy-keys)」を参照してください。
## Pipelines を使用したサービスコントロールポリシー
サービスコントロールポリシー (SCP) は、組織のアクセス許可の管理に使用できる組織ポリシーの一種です。SCP では、組織のすべてのアカウントで使用可能な最大アクセス許可を一元的に制御できます。組織内でパイプラインを使用することで、データサイエンティストが AWS コンソールを操作することなくパイプラインの実行を管理できるようになります。
Amazon S3 へのアクセスを制限する SCP で VPC を使用する場合、他の Amazon S3 リソースへのアクセスをパイプラインに許可するための手順を実行する必要があります。
VPC 外の Amazon S3 に Pipelines が `JsonGet` 関数を使用してアクセスできるようにするには、Pipelines を使用するロールが Amazon S3 にアクセスできるように組織の SCP を更新します。これを行うには、プリンシパルタグと条件キーを使用して、パイプラインの実行ロールを介して Pipelines エグゼキュターが使用するロールの例外を作成します。
**VPC 外の Amazon S3 へのアクセスを Pipelines に許可するには**
1. 「[IAM ユーザーとロールのタグ付け](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html)」の手順に従って、パイプラインの実行ロールに固有のタグを作成します。
1. 作成したタグの `Aws:PrincipalTag IAM` 条件キーを使用して、SCP で例外を付与します。詳細については、「[サービスコントロールポリシーの作成、更新、削除](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_create.html)」を参照してください。
# Pipelines のクロスアカウントサポートを設定する
Amazon SageMaker Pipelines のクロスアカウントサポートにより、異なる AWS アカウントで運用されている他のチームや組織と機械学習パイプラインでコラボレーションできます。クロスアカウントパイプライン共有を設定すると、パイプラインへの制御されたアクセスを許可し、他のアカウントにパイプラインの詳細の表示、実行のトリガー、実行のモニタリングを許可できます。次のトピックでは、クロスアカウントパイプライン共有を設定する方法、共有リソースで使用できるさまざまなアクセス許可ポリシー、SageMaker AI への直接 API コールを通じて共有パイプラインエンティティにアクセスして操作する方法について説明します。
## クロスアカウントパイプライン共有を設定する
SageMaker AI は [AWS Resource Access Manager](https://docs.aws.amazon.com/ram/latest/userguide/what-is.html) (AWS RAM) を使用して、パイプラインエンティティをアカウント間で安全に共有できるようにします。
### リソース共有を作成する
1. [AWS RAM コンソール](https://console.aws.amazon.com/ram/home)で **[リソース共有を作成]** を選択します。
1. リソース共有の詳細を指定する際は、Pipelines のリソースタイプを選択し、共有するパイプラインを 1 つまたは複数選択します。パイプラインを他のアカウントと共有すると、その実行もすべて暗黙的に共有されます。
1. アクセス許可をリソース共有に関連付けます。デフォルトの読み取り専用アクセス許可ポリシーまたは拡張パイプライン実行許可ポリシーのいずれかを選択します。詳細については、「[Pipelines リソースのアクセス許可ポリシー](#build-and-manage-xaccount-permissions)」を参照してください。
**注記**
拡張パイプライン実行ポリシーを選択した場合、共有アカウントによって呼び出されるすべての開始、停止、再試行コマンドは、パイプラインを共有した AWS アカウントのリソースを使用することに注意してください。
1. AWS アカウント IDs を使用して、共有リソースへのアクセスを許可するアカウントを指定します。
1. リソース共有の設定を確認し、**[リソース共有の作成]** を選択します。リソース共有とプリンシパルの関連付けが完了するまでに数分かかることがあります。
詳細については、「AWS Resource Access Manager ユーザーガイド」の「[Sharing your AWS resources](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html)」を参照してください。**
### リソース共有の招待に対する返信を受け取る
リソース共有とプリンシパルの関連付けが設定されると、指定された AWS アカウントにリソース共有への参加の招待が届きます。共有リソースにアクセスするには、 AWS アカウントが招待を受け入れる必要があります。
を通じてリソース共有の招待を受け入れる方法の詳細については AWS RAM、*AWS 「 Resource Access Manager* [ユーザーガイド」の「共有 AWS リソース](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-shared.html)の使用」を参照してください。
## Pipelines リソースのアクセス許可ポリシー
リソース共有を作成する際は、サポートされている 2 つのアクセス許可ポリシーから 1 つを選択して SageMaker AI パイプラインリソースタイプに関連付けます。どちらのポリシーも、選択したパイプラインとそのすべての実行へのアクセス許可を付与します。
### デフォルトの読み取り専用のアクセス許可
`AWSRAMDefaultPermissionSageMakerPipeline` ポリシーは以下の読み取り専用アクションを許可します。
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:Search"
```
### 拡張パイプライン実行アクセス許可
`AWSRAMPermissionSageMakerPipelineAllowExecution` ポリシーには、デフォルトのポリシーの読み取り専用アクセス許可がすべて含まれており、共有アカウントがパイプラインの実行を開始、停止、再試行することも許可されます。
**注記**
拡張パイプライン実行アクセス許可ポリシーを使用する場合は、 AWS リソースの使用に注意してください。このポリシーにより、共有アカウントはパイプライン実行の開始、停止、再試行が許可されます。共有パイプラインの実行に使用されるリソースはすべて所有者アカウントによって消費されます。
拡張パイプライン実行アクセス許可ポリシーでは、以下のアクションを許可します。
```
"sagemaker:DescribePipeline"
"sagemaker:DescribePipelineDefinitionForExecution"
"sagemaker:DescribePipelineExecution"
"sagemaker:ListPipelineExecutions"
"sagemaker:ListPipelineExecutionSteps"
"sagemaker:ListPipelineParametersForExecution"
"sagemaker:StartPipelineExecution"
"sagemaker:StopPipelineExecution"
"sagemaker:RetryPipelineExecution"
"sagemaker:Search"
```
## 直接 API コールを通じて共有パイプラインエンティティにアクセスする
クロスアカウントパイプライン共有を設定すると、パイプライン ARN で次の SageMaker API アクションを呼び出すことができます。
**注記**
API コマンドは、リソース共有に関連付けられたアクセス許可に含まれている場合にのみ呼び出すことができます。`AWSRAMPermissionSageMakerPipelineAllowExecution` ポリシーを選択すると、開始、停止、再試行コマンドは、パイプラインを共有した AWS アカウントのリソースを使用します。
+ [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)
# Pipeline のパラメータ
パラメータを使用すると、パイプライン定義に変数を導入できます。定義したパラメータは、パイプライン定義全体で参照できます。パラメータはデフォルト値を持ちますが、パイプラインの実行の開始時にパラメータ値を指定することによってオーバーライドできます。デフォルト値は、パラメータタイプに一致するインスタンスでなければなりません。ステップ定義で使用されるすべてのパラメータは、パイプライン定義で定義する必要があります。このトピックでは、定義できるパラメータとその実装方法について説明します。
Amazon SageMaker Pipelines では、以下のパラメータタイプをサポートしています。
+ `ParameterString` — 文字列パラメータを表します。
+ `ParameterInteger` — 整数パラメータを表します。
+ `ParameterFloat` — float パラメータを表します。
+ `ParameterBoolean` — Python ブール型を表します。
パラメータは、次の形式になります。
```
= (
name="",
default_value=
)
```
パラメータの実装例は次のとおりです。
```
from sagemaker.workflow.parameters import (
ParameterInteger,
ParameterString,
ParameterFloat,
ParameterBoolean
)
processing_instance_count = ParameterInteger(
name="ProcessingInstanceCount",
default_value=1
)
```
パラメータは、次の例に示すようにパイプラインの作成時に渡します。
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[
processing_instance_count
],
steps=[step_process]
)
```
次の例に示すように、デフォルト値とは異なるパラメータ値をパイプラインの実行に渡すこともできます。
```
execution = pipeline.start(
parameters=dict(
ProcessingInstanceCount="2",
ModelApprovalStatus="Approved"
)
)
```
パラメータは、`[ sagemaker.workflow.functions.Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.functions.Join)` などの SageMaker Python SDK 関数を使用して操作できます。パラメータの詳細については、「[SageMaker パイプラインのパラメータ](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#parameters)」を参照してください。
パイプラインパラメータの既知の制限については、「[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable)」の「*[Limitations - Parameterization](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#parameterization)*」を参照してください。
# Pipelines のステップ
Pipelines は、複数のステップで構成されています。これらのステップでは、プロパティを使用して、パイプラインが実行するアクションとステップ間の関係を定義します。次のページでは、ステップのタイプ、プロパティ、ステップ間の関係性について説明します。
**Topics**
+ [ステップを追加する](build-and-manage-steps-types.md)
+ [統合の追加](build-and-manage-steps-integration.md)
+ [ステップのプロパティ](#build-and-manage-properties)
+ [ステップの並列処理](#build-and-manage-parallelism)
+ [ステップ間のデータ依存関係](#build-and-manage-data-dependency)
+ [ステップ間のカスタム依存関係](#build-and-manage-custom-dependency)
+ [ステップでのカスタムイメージ](#build-and-manage-images)
# ステップを追加する
以下では、各ステップタイプの要件について説明し、ステップの実装例と、ステップを Pipelines に追加する方法について説明します。これらは、必要なリソースと入力を提供しないため、機能する実装ではありません。これらのステップの実装に関するチュートリアルについては、「[Pipelines のアクション](pipelines-build.md)」を参照してください。
**注記**
`@step` デコレータを使用してコードを Pipeline ステップに変換することで、ローカルの機械学習コードからステップを作成することもできます。詳細については、「[@step デコレータ](#step-type-custom)」を参照してください。
Amazon SageMaker Pipelines では、以下のステップタイプをサポートしています。
+ [コードを実行する](#step-type-executecode)
[Processing](#step-type-processing)
+ [トレーニング](#step-type-training)
+ [チューニング](#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)
+ [変換](#step-type-transform)
+ [条件](#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)
+ [ノートブックジョブ](#step-type-notebook-job)
+ [失敗](#step-type-fail)
## @step デコレータ
drag-and-dropパイプライン UI で高度な SageMaker AI 機能やその他の AWS サービスを活用するカスタム ML ジョブをオーケストレーションする場合は、 を使用します[コードステップを実行する](#step-type-executecode)。
`@step` デコレータを使用すると、ローカル機械学習コードからステップを作成できます。コードをテストしたら、`@step` デコレータで注釈を付けることで、関数を SageMaker AI パイプラインステップに変換できます。パイプラインは、`@step` デコレータ関数の出力をステップとしてパイプラインに渡すと、パイプラインを作成して実行します。単一または複数の `@step` デコレータ関数と従来の SageMaker AI パイプラインステップを含むマルチステップ DAG パイプラインを作成することもできます。`@step` デコレータを使用してステップを作成する方法の詳細については、「[@step デコレータを使用した Python コードのリフトアンドシフト](pipelines-step-decorator.md)」を参照してください。
## コードステップを実行する
Pipelines のドラッグアンドドロップ UI では、**[コード実行]** ステップを使用して、パイプラインステップとして独自のコードを実行できます。Python 関数、スクリプト、またはノートブックをアップロードして、パイプラインの一部として実行できます。高度な SageMaker AI 機能やその他の AWS サービスを活用するカスタム ML ジョブをオーケストレーションする場合は、このステップを使用する必要があります。
**[コード実行]** ステップは、Amazon SageMaker AI のデフォルトの Amazon S3 バケットにファイルをアップロードします。このバケットには、必要なクロスオリジンリソース共有 (CORS) アクセス許可が設定されていない場合があります。CORS アクセス許可の付与の詳細については、「[入力イメージデータの CORS 要件](sms-cors-update.md)」を参照してください。
**[コード実行]** ステップでは、Amazon SageMaker トレーニングジョブを使用してコードを実行します。IAM ロールに `sagemaker:DescribeTrainingJob` API と `sagemaker:CreateTrainingJob` API のアクセス許可があることを確認します。Amazon SageMaker AI に必要なすべてのアクセス許可とその設定方法については、「[Amazon SageMaker AI API アクセス許可: アクション、アクセス許可、リソースの参照](api-permissions-reference.md)」を参照してください。
Pipeline Designer を使用してパイプラインにコード実行ステップを追加するには、次の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Amazon SageMaker Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. **[指定なし]** をクリックします。
1. 左側のサイドバーで、**[コード実行]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[コード実行]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。
1. 単一のファイルをアップロードして実行することも、複数のアーティファクトを含む圧縮フォルダーをアップロードすることもできます。
1. 単一ファイルアップロードの場合、ノートブック、Python 関数、またはスクリプトのオプションパラメータを指定できます。
1. Python 関数を提供する場合は、`file.py:` 形式でハンドラーを指定する必要があります。
1. 圧縮フォルダをアップロードする場合は、コードへの相対パスを指定する必要があります。必要に応じて、圧縮フォルダ内の `requirements.txt` ファイルまたは初期化スクリプトへのパスを指定できます。
1. キャンバスに、追加した **[コード実行]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[コード実行]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[コード実行]** ステップの直前のステップが含まれている場合は、**[コード実行]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。**[コード実行]** ステップからの出力は、Python 関数で参照できます。
## 処理ステップ
処理ステップを使用すると、データ処理のための処理ジョブを作成できます。ジョブの処理の詳細については、「[データを処理して、モデルを評価する](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html)」を参照してください。
------
#### [ Pipeline Designer ]
Pipeline Designer を使用してパイプラインに処理ステップを追加するには、次の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Amazon SageMaker Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. 左側のサイドバーで、**[データ処理]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[データ処理]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。これらのタブのフィールドの詳細については、「[sagemaker.workflow.steps.ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)」を参照してください。
1. キャンバスに、追加した **[データ処理]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[データ処理]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[コード実行]** ステップの直前のステップが含まれている場合は、**[コード実行]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。
------
#### [ SageMaker Python SDK ]
処理ステップには、プロセッサ、処理コードを定義する Python スクリプト、処理の出力、ジョブ引数が必要です。以下の例は、`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")
)
```
**ランタイムパラメータを渡す**
次の例は、PySpark プロセッサから `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,
)
```
処理ステップの要件の詳細については、「[sagemaker.workflow.steps.ProcessingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.ProcessingStep)」のドキュメントを参照してください。詳細な例については、「[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)」サンプルノートブックを参照してください。「*Define a Processing Step for Feature Engineering*」セクションに詳細が記載されています。
------
## トレーニングステップ
トレーニングステップを使用すると、モデルをトレーニングするためのトレーニングジョブを作成できます。トレーニングジョブの詳細については、「[Amazon SageMaker AI でモデルをトレーニングする](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html)」を参照してください。
トレーニングステップには、推定器と、トレーニングおよび検証データの入力が必要です。
------
#### [ Pipeline Designer ]
Pipeline Designer を使用してパイプラインにトレーニングステップを追加するには、次の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Amazon SageMaker Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. **[指定なし]** をクリックします。
1. 左側のサイドバーで、**[モデルをトレーニング]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[モデルをトレーニング]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。これらのタブのフィールドの詳細については、「[sagemaker.workflow.steps.TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep)」を参照してください。
1. キャンバスに、追加した **[モデルをトレーニング]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[モデルをトレーニング]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[モデルをトレーニング]** ステップの直前のステップが含まれている場合は、**[モデルをトレーニング]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。
------
#### [ SageMaker Python SDK ]
以下の例は、`TrainingStep` 定義の作成方法を示しています。トレーニングステップの要件の詳細については、「[sagemaker.workflow.steps.TrainingStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TrainingStep)」のドキュメントを参照してください。
```
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,
)
```
------
## チューニングステップ
チューニングステップを使用すると、ハイパーパラメータチューニングジョブを作成できます。このジョブは、ハイパーパラメータの最適化 (HPO) とも呼ばれます。ハイパーパラメータチューニングジョブは、複数のトレーニングジョブを実行し、各ジョブでモデルバージョンが生成されます。ハイパーパラメータのチューニングについては、「[SageMaker AI の自動モデルチューニング](automatic-model-tuning.md)」を参照してください。
チューニングジョブは、パイプラインの SageMaker AI 実験に関連付けられ、トレーニングジョブがトライアルとして作成されます。詳細については、「[Experiments の統合](pipelines-experiments.md)」を参照してください。
チューニングステップには、[HyperparameterTuner](https://sagemaker.readthedocs.io/en/stable/api/training/tuner.html) とトレーニングの入力が必要です。`HyperparameterTuner` の `warm_start_config` パラメータを指定すると、以前のチューニングジョブを再トレーニングできます。ハイパーパラメータのチューニングとウォームスタートの詳細については、「[ウォームスタートのハイパーパラメータ調整ジョブを実行する](automatic-model-tuning-warm-start.md)」を参照してください。
[sagemaker.workflow.steps.TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep) クラスの [get\$1top\$1model\$1s3\$1uri](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep.get_top_model_s3_uri) メソッドを使用すると、パフォーマンスに優れたモデルバージョンのいずれかからモデルアーティファクトを取得できます。SageMaker AI パイプラインでのチューニングステップの使用方法を解説したノートブックについては、「[sagemaker-pipelines-tuning-step.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/tuning-step/sagemaker-pipelines-tuning-step.ipynb)」を参照してください。
**重要**
チューニングステップは、Amazon SageMaker Python SDK v2.48.0 と Amazon SageMaker Studio v3.8.0 で導入されました。チューニングステップを使用する前に Studio Classic をアップデートする必要があります。アップデートしないと、パイプライン DAG は表示されません。Studio Classic を更新するには、「[Amazon SageMaker Studio Classic をシャットダウンして更新する](studio-tasks-update-studio.md)」を参照してください。
以下の例は、`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"))
)
```
**最適なモデルバージョンを取得する**
以下の例は、`get_top_model_s3_uri` メソッドを使用して、チューニングジョブから最適なモデルバージョンを取得する方法を示しています。最大でパフォーマンス上位 50 件のバージョンが利用でき、[HyperParameterTuningJobObjective](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_HyperParameterTuningJobObjective.html) に従ってランク付けされています。`top_k` 引数はバージョンのインデックスです。`top_k=0` がパフォーマンスが最も高いバージョン、`top_k=49` がパフォーマンスが最も低いバージョンになります。
```
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()
),
...
)
```
チューニングステップの要件の詳細については、「[sagemaker.workflow.steps.TuningStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TuningStep)」のドキュメントを参照してください。
## ファインチューニングステップ
ファインチューニングでは、Amazon SageMaker JumpStart からの事前トレーニング済みの基盤モデルを新しいデータセットでトレーニングします。転移学習とも呼ばれるこのプロセスでは、より小さなデータセットを使用し、より短時間のトレーニングで正確なモデルを生成できます。モデルをファインチューニングする際は、デフォルトのデータセットを使用することも、独自のデータを選択することもできます。JumpStart から基盤モデルをファインチューニングする方法の詳細については、「[モデルを微調整する](jumpstart-fine-tune.md)」を参照してください。
ファインチューニングステップでは、Amazon SageMaker トレーニングジョブを使用してモデルをカスタマイズします。IAM ロールに、パイプラインでファインチューニングジョブを実行するための `sagemaker:DescribeTrainingJob` API と `sagemaker:CreateTrainingJob` API のアクセス許可があることを確認します。Amazon SageMaker AI に必要なアクセス許可とその設定方法については、「[Amazon SageMaker AI API アクセス許可: アクション、アクセス許可、リソースの参照](api-permissions-reference.md)」を参照してください。
ドラッグアンドドロップエディタを使用してパイプラインに **[モデルを微調整]** ステップを追加するには、以下の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. **[指定なし]** をクリックします。
1. 左側のサイドバーで、**[モデルを微調整]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[モデルを微調整]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。
1. キャンバスに、追加した **[モデルを微調整]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[モデルを微調整]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[モデルを微調整]** ステップの直前のステップが含まれている場合は、**[モデルを微調整]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。
## AutoML ステップ
[AutoML](https://sagemaker.readthedocs.io/en/stable/api/training/automl.html) API を使用して AutoML ジョブを作成し、モデルを自動的にトレーニングします。AutoML ジョブの詳細については、「[Automate model development with Amazon SageMaker Autopilot](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html)」を参照してください。
**注記**
現在、AutoML ステップは[アンサンブルトレーニングモード](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-model-support-validation.html)のみをサポートしています。
以下の例は、`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,
)
```
**最適なモデルバージョンを取得する**
AutoML ステップは、複数のモデル候補を自動的にトレーニングします。以下のとおり `get_best_auto_ml_model` メソッドを使用して、AutoML ジョブから最適な目標メトリクスを持つモデルを取得します。モデルアーティファクトにアクセスするには、IAM `role` を使用する必要もあります。
```
best_model = step_automl.get_best_auto_ml_model(role=)
```
詳細については、SageMaker Python SDK の「[AutoML](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.automl_step.AutoMLStep)」のステップを参照してください。
## モデルステップ
SageMaker AI モデルを作成または登録するには、`ModelStep` を使用します。`ModelStep` 要件の詳細については、「[sagemaker.workflow.model\$1step.ModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.model_step.ModelStep)」のドキュメントを参照してください。
### モデルを作成する
SageMaker AI モデルを作成するには、`ModelStep` を使用できます。`ModelStep` には、モデルアーティファクトと、モデルの作成に使用する必要がある SageMaker AI インスタンスタイプに関する情報が必要です。SageMaker AI モデルの詳細については、「[Amazon SageMaker AI でモデルをトレーニングする](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html)」を参照してください。
以下の例は、`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"),
)
```
### モデルの登録
`ModelStep` を使用して `sagemaker.model.Model` または `sagemaker.pipeline.PipelineModel` を Amazon SageMaker モデルレジストリに登録できます。`PipelineModel` は推論パイプラインを表します。これは、推論要求を処理する連続したコンテナで構成されるモデルです。モデルの登録方法の詳細については、「[Model Registry を使用したモデル登録デプロイ](model-registry.md)」を参照してください。
次の例は、`PipelineModel` を登録する `ModelStep` の作成方法を示しています。
```
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,
)
```
## モデルの作成ステップ
モデルの作成ステップを使用すると、SageMaker AI モデルを作成できます。SageMaker AI モデルの詳細については、「[Amazon SageMaker でモデルをトレーニングする](how-it-works-training.md)」を参照してください。
モデル作成ステップには、モデルアーティファクトと、モデルの作成に使用する必要がある SageMaker AI インスタンスタイプに関する情報が必要です。次の例は、モデルステップ定義を作成する方法を説明しています。モデルの作成ステップの要件の詳細については、「[sagemaker.workflow.steps.CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep)」のドキュメントを参照してください。
------
#### [ Pipeline Designer ]
パイプラインにモデルの作成ステップを追加するには、次の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. **[指定なし]** をクリックします。
1. 左側のサイドバーで、**[モデルの作成]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[モデルの作成]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。これらのタブのフィールドの詳細については、「[sagemaker.workflow.steps.CreateModelStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.CreateModelStep)」を参照してください。
1. キャンバスに、追加した **[モデルの作成]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[モデルの作成]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[モデルの作成]** ステップの直前のステップが含まれている場合は、**[モデルの作成]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。
------
#### [ SageMaker Python SDK ]
**重要**
SageMaker Python AI SDK v2.90.0 以降では、[モデルステップ](#step-type-model) を使用してモデルを作成することをお勧めします。`CreateModelStep` は SageMaker Python SDK の以前のバージョンでも引き続き動作しますが、アクティブなサポートは終了しています。
```
from sagemaker.workflow.steps import CreateModelStep
step_create_model = CreateModelStep(
name="AbaloneCreateModel",
model=best_model,
inputs=inputs
)
```
------
## モデルステップの登録
モデルの登録ステップでは、SageMaker Model Registry にモデルを登録します。
------
#### [ Pipeline Designer ]
Pipeline Designer を使用してパイプラインからモデルを登録するには、次の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Amazon SageMaker Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. **[指定なし]** をクリックします。
1. 左側のサイドバーで、**[モデルの登録]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[モデルの登録]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。これらのタブのフィールドの詳細については、「[sagemaker.workflow.step\$1collections.RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel)」を参照してください。
1. キャンバスに、追加した **[モデルの登録]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[モデルの登録]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[モデルの登録]** ステップの直前のステップが含まれている場合は、**[モデルの登録]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。
------
#### [ SageMaker Python SDK ]
**重要**
SageMaker Python AI SDK v2.90.0 以降では、[モデルステップ](#step-type-model) を使用してモデルを登録することをお勧めします。`RegisterModel` は SageMaker Python SDK の以前のバージョンでも引き続き動作しますが、アクティブなサポートは終了しています。
`RegisterModel` ステップは、[sagemaker.model.Model](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html) または [sagemaker.pipeline.PipelineModel](https://sagemaker.readthedocs.io/en/stable/api/inference/pipeline.html#pipelinemodel) を Amazon SageMaker モデルレジストリに登録するために使用します。`PipelineModel` は推論パイプラインを表します。これは、推論要求を処理する連続したコンテナで構成されるモデルです。
モデルの登録方法の詳細については、「[Model Registry を使用したモデル登録デプロイ](model-registry.md)」を参照してください。`RegisterModel` ステップの要件の詳細については、「[sagemaker.workflow.step\$1collections.RegisterModel](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_collections.RegisterModel)」のドキュメントを参照してください。
次の例は、`PipelineModel` を登録する `RegisterModel` ステップの作成方法を示しています。
```
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',
)
```
`model` が指定されていない場合、モデル登録ステップには、以下の例に示すような推定器が必要です。
```
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
)
```
------
## モデルのデプロイ (エンドポイント) ステップ
Pipeline Designer で、モデルのデプロイ (エンドポイント) ステップを使用して、モデルをエンドポイントにデプロイします。新しいエンドポイントを作成することも、既存のエンドポイントを使用することもできます。リアルタイム推論は、リアルタイム、インタラクティブ、低レイテンシーの要件がある推論ワークロードに最適です。SageMaker AI Hosting サービスにモデルをデプロイすると、推論に使用できるリアルタイムエンドポイントを取得できます。このようなエンドポイントはフルマネージドであり、自動スケーリングをサポートしています。SageMaker AI でのリアルタイム推論の詳細については、「[リアルタイム推論](realtime-endpoints.md)」を参照してください。
デプロイモデルステップをパイプラインに追加する前に、IAM ロールに以下のアクセス許可が付与されていることを確認してください。
+ `sagemaker:CreateModel`
+ `sagemaker:CreateEndpointConfig`
+ `sagemaker:CreateEndpoint`
+ `sagemaker:UpdateEndpoint`
+ `sagemaker:DescribeModel`
+ `sagemaker:DescribeEndpointConfig`
+ `sagemaker:DescribeEndpoint`
SageMaker AI に必要なすべてのアクセス許可とその設定方法については、「[Amazon SageMaker AI API アクセス許可: アクション、アクセス許可、リソースの参照](api-permissions-reference.md)」を参照してください。
ドラッグアンドドロップエディタを使用して Pipeline に [モデルのデプロイ] ステップを追加するには、以下の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. **[指定なし]** をクリックします。
1. 左側のサイドバーで、**[モデルの登録 (エンドポイント)]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[モデルのデプロイ (エンドポイント)]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。
1. キャンバスに、追加した **[モデルのデプロイ (エンドポイント)]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[モデルのデプロイ (エンドポイント)]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[モデルのデプロイ (エンドポイント)]** ステップの直前のステップが含まれている場合は、**[モデルのデプロイ (エンドポイント)]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。
## 変換ステップ
変換ステップは、バッチ変換でデータセット全体に対して推論を実行するために使用します。バッチ変換の詳細については、「[推論パイプラインを使用したバッチ変換](inference-pipeline-batch.md)」を参照してください。
変換ステップには、変換器と、バッチ変換を実行する対象のデータが必要です。次の例は、変換ステップの定義の作成方法を説明しています。変換ステップの要件の詳細については、「[sagemaker.workflow.steps.TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep)」のドキュメントを参照してください。
------
#### [ Pipeline Designer ]
ドラッグアンドドロップエディタを使用して Pipeline に [バッチ変換] ステップを追加するには、以下の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. **[指定なし]** をクリックします。
1. 左側のサイドバーで、**[モデルのデプロイ (エンドポイント)]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[モデルのデプロイ (バッチ変換)]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。これらのタブのフィールドの詳細については、「[sagemaker.workflow.steps.TransformStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.steps.TransformStep)」を参照してください。
1. キャンバスに、追加した **[モデルのデプロイ (バッチ変換)]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[モデルのデプロイ (バッチ変換)]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[モデルのデプロイ (バッチ変換)]** ステップの直前のステップが含まれている場合は、**[モデルのデプロイ (バッチ変換)]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。
------
#### [ 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"),
)
```
------
## 条件ステップ
条件ステップを使用すると、ステップのプロパティの条件を評価し、パイプラインで次に実行するアクションを評価できます。
条件ステップには、以下が必要です。
+ 条件のリスト
+ 条件が `true` と評価された場合に実行するステップのリスト
+ 条件が `false` と評価された場合に実行するステップのリスト
------
#### [ Pipeline Designer ]
Pipeline Designer を使用してパイプラインに条件ステップを追加するには、次の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Amazon SageMaker Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. **[指定なし]** をクリックします。
1. 左側のサイドバーで、**[条件]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[条件]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。これらのタブのフィールドの詳細については、「[sagemaker.workflow.condition\$1step.ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.condition_step.ConditionStep)」を参照してください。
1. キャンバスに、追加した **[条件]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[条件]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[条件]** ステップの直前のステップが含まれている場合は、**[条件]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。
------
#### [ SageMaker Python SDK ]
以下の例は、`ConditionStep` 定義の作成方法を示しています。
**制限事項**
+ Pipelines は、ネストされた条件ステップの使用をサポートしていません。条件ステップを別の条件ステップの入力として渡すことはできません。
+ 条件ステップの両方のブランチで同じステップを使用することはできません。両方のブランチに同じステップ機能が必要な場合は、ステップを複製して別の名前を付けます。
```
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=[]
)
```
`ConditionStep` 要件の詳細については、「[sagemaker.workflow.condition\$1step.ConditionStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#conditionstep)」の API リファレンスを参照してください。サポートされる条件の詳細については、「SageMaker AI Python SDK ドキュメント」の「*[Amazon SageMaker Pipelines - 条件](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#conditions)*」を参照してください。
------
## コールバックステップ
`Callback` ステップを使用して、Amazon SageMaker Pipelines によって直接提供されていないプロセスと AWS サービスをワークフローに追加します。`Callback` ステップを実行すると、次の手順が実行されます。
+ Pipelines は、ユーザー指定の Amazon Simple Queue Service (Amazon SQS) キューにメッセージを送信します。このようなメッセージには、Pipelines が生成したトークンと、ユーザーが指定した入力パラメータのリストが含まれます。メッセージの送信後、Pipelines はユーザーからの応答を待ちます。
+ ユーザーは Amazon SQS キューからメッセージを取得し、カスタムプロセスを開始します。
+ プロセスが終了すると、ユーザーは次のいずれかの API を呼び出し、Pipelines が生成した以下のトークンを送信します。
+ [SendPipelineExecutionStepSuccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepSuccess.html) - 出力パラメータのリストと共に送信
+ [SendPipelineExecutionStepFailure](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_SendPipelineExecutionStepFailure.html) - 失敗の理由と共に送信
+ API コールにより、Pipelines はパイプラインプロセスを続行するか、プロセスを失敗させます。
`Callback` ステップの要件の詳細については、「[sagemaker.workflow.callback\$1step.CallbackStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.callback_step.CallbackStep)」のドキュメントを参照してください。詳細なソリューションについては、「[SageMaker Pipelines を拡張して、コールバックステップを使用してカスタムステップを含める](https://aws.amazon.com/blogs/machine-learning/extend-amazon-sagemaker-pipelines-to-include-custom-steps-using-callback-steps/)」を参照してください。
**重要**
`Callback` ステップは、Amazon SageMaker Python SDK v2.45.0 と Amazon SageMaker Studio v3.6.2 で導入されました。`Callback` ステップを使用する前に Studio Classic をアップデートする必要があります。アップデートしないと、パイプライン DAG は表示されません。Studio Classic を更新するには、「[Amazon SageMaker Studio Classic をシャットダウンして更新する](studio-tasks-update-studio.md)」を参照してください。
次のサンプルは、上記のプロシージャの実装の 1 例を説明しています。
```
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={...}
)
'
```
**注記**
`CallbackStep` の出力パラメータはネストしないでください。例えば、ネストされたディクショナリを出力パラメータとして使用すると、そのディクショナリは単一の文字列として扱われます (例: `{"output1": "{\"nested_output1\":\"my-output\"}"}` など)。ネストされた値を指定した場合、特定の出力パラメータを参照しようとすると、SageMaker AI は再試行不可能なクライアントエラーを返します。
**動作を停止する**
`Callback` ステップの実行中は、パイプラインプロセスが停止しません。
実行中の `Callback` ステップがあるパイプラインプロセスで [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html) を呼び出すと、Pipelines は Amazon SQS メッセージを SQS キューに送信します。SQS メッセージの本文には、`Stopping` に設定された **[Status]** (ステータス) フィールドが含まれます。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"
}
```
メッセージを受け取ったら、必要なアクション (リソースのクリーンアップなど) を実行するロジックを Amazon SQS メッセージコンシューマーに追加する必要があります。次に、`SendPipelineExecutionStepSuccess` または `SendPipelineExecutionStepFailure` への呼び出しを追加します。
Pipelines は、ここのような呼び出しのいずれかを受け取った場合にのみ、パイプラインプロセスを停止します。
## Lambda ステップ
Lambda ステップを使用して AWS Lambda 関数を実行します。既存の Lambda 関数を実行できるほか、SageMaker AIで新しい Lambda 関数を作成して実行することもできます。既存の Lambda 関数を使用する場合は、SageMaker AI パイプライン AWS リージョン と同じ にある必要があります。SageMaker AI パイプラインでの Lambda ステップの使用方法を解説したノートブックについては、「[sagemaker-pipelines-lambda-step.ipynb](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/lambda-step/sagemaker-pipelines-lambda-step.ipynb)」を参照してください。
**重要**
Lambda ステップは、Amazon SageMaker Python SDK v2.51.0 と Amazon SageMaker Studio v3.9.1 で導入されました。Lambda ステップを使用する前に Studio Classic をアップデートする必要があります。アップデートしないと、パイプライン DAG は表示されません。Studio Classic を更新するには、「[Amazon SageMaker Studio Classic をシャットダウンして更新する](studio-tasks-update-studio.md)」を参照してください。
SageMaker AI は、Lambda 関数を作成、更新、呼び出し、削除するための [sagemaker.lambda\$1helper.Lambda](https://sagemaker.readthedocs.io/en/stable/api/utility/lambda_helper.html) クラスを提供しています。`Lambda` には以下の署名があります。
```
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
...
)
```
[sagemaker.workflow.lambda\$1step.LambdaStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.lambda_step.LambdaStep) クラスには `Lambda` タイプの引数 `lambda_func` があります。既存の Lambda 関数は、関数の Amazon リソースネーム (ARN) を `function_arn` に指定するだけで呼び出すことができます。`function_arn` の値を指定しない場合は、`handler` と以下のいずれかを指定する必要があります。
+ `zipped_code_dir` - 圧縮された Lambda 関数のパス
`s3_bucket` - `zipped_code_dir` がアップロードされる Amazon S3 バケット
+ `script` - Lambda 関数スクリプトファイルのパス
以下の例は、既存の Lambda 関数を呼び出す `Lambda` ステップ定義の作成方法を示しています。
```
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"
]
)
```
以下の例は、Lambda 関数スクリプトを使用して Lambda 関数を作成して呼び出す `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"
]
)
```
**入力と出力**
`Lambda` 関数に入力または出力がある場合、これらも `Lambda` ステップで定義する必要があります。
**注記**
入力パラメータと出力パラメータはネストしないでください。例えば、ネストされたディクショナリを出力パラメータとして使用すると、そのディクショナリは単一の文字列として扱われます (例: `{"output1": "{\"nested_output1\":\"my-output\"}"}`)。ネストされた値を指定して後で参照しようとすると、再試行されないクライアントエラーが発生します。
`Lambda` ステップを定義する場合、`inputs` はキーと値のペアの辞書でなければなりません。`inputs` 辞書の各値は、プリミティブ型 (文字列、整数、または浮動小数点) であることが必要です。ネストされたオブジェクトはサポートされません。定義しない場合、`inputs` 値はデフォルトで `None` になります。
`outputs` 値は、キーのリストでなければなりません。これらのキーは、`Lambda` 関数の出力に定義されている辞書を参照します。`inputs` と同様に、これらのキーはプリミティブ型でなければならず、ネストされたオブジェクトはサポートされません。
**タイムアウトと停止動作**
`Lambda` クラスには、Lambda 関数の実行が可能な最大時間を指定する `timeout` 引数があります。デフォルト値は 120 秒で、最大値は 10 分です。Lambda 関数の実行中にタイムアウトに達すると、Lambda ステップは失敗しますが、Lambda 関数は引き続き実行されます。
Lambda ステップによって呼び出された Lambda 関数を停止できないため、Lambda ステップの実行中はパイプラインプロセスを停止できません。Lambda 関数の実行中にプロセスを停止すると、パイプラインは関数が終了するか、タイムアウトに達するまで待機します。どちらか先に発生したほうのタイミングとなります。その後、プロセスは停止します。Lambda 関数が終了した場合、パイプラインプロセスのステータスは `Stopped` になります。タイムアウトに達した場合、パイプラインプロセスのステータスは `Failed` になります。
## ClarifyCheck ステップ
`ClarifyCheck` ステップを使用すると、バイアス分析とモデルの説明可能性に関するベースラインドリフトチェックを前のベースラインに対して実行できます。次に、`model.register()` メソッドを使用して[ベースラインを生成して登録し](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations)、`[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)` を使用してそのメソッドの出力を [モデルステップ](#step-type-model) に渡すことができます。このようなドリフトチェック用のベースラインは、モデルエンドポイントのために Amazon SageMaker Model Monitor を使用できます。このため、[ベースライン](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html)の提案を別途に行う必要はありません。
`ClarifyCheck` ステップでは、ドリフトチェック用のベースラインをモデルレジストリからプルすることもできます。`ClarifyCheck` ステップでは、SageMaker Clarify の事前構築済みコンテナを使用します。このコンテナは、制約の提案や特定のベースラインに対する制約の検証など、さまざまなモデルモニタリング機能を提供します。詳細については、「[構築済みの SageMaker Clarify コンテナ](clarify-processing-job-configure-container.md)」を参照してください。
### ClarifyCheck ステップを設定する
パイプラインで使用するたびに以下のチェックタイプの 1 つのみを実行するように `ClarifyCheck` ステップを設定できます。
+ データバイアスのチェック
+ モデルバイアスのチェック
+ モデルの説明可能性のチェック
実行するには、`clarify_check_config` パラメータに以下のいずれかのチェックタイプ値を指定します。
+ `DataBiasCheckConfig`
+ `ModelBiasCheckConfig`
+ `ModelExplainabilityCheckConfig`
`ClarifyCheck` ステップは、SageMaker AI Clarify の事前構築済みコンテナを実行する処理ジョブを起動し、[チェックと処理ジョブ](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-configure-processing-jobs.html)専用の設定が必要となります。`ClarifyCheckConfig` と `CheckJobConfig` は、このような設定のヘルパー関数です。このようなヘルパー関数は、モデルバイアス、データバイアス、またはモデルの説明可能性をチェックするために SageMaker Clarify 処理ジョブが計算する方法に合わせて調整されます。詳細については、「[バイアス分析と説明可能性のための SageMaker Clarify 処理ジョブを実行する](clarify-processing-job-run.md)」を参照してください。
### ドリフトチェックのステップ動作を制御する
`ClarifyCheck` ステップには、その動作を制御するために、以下の 2 つのブールフラグが必要です。
+ `skip_check`: このパラメータでは、前のベースラインに対するドリフトチェックをスキップするかどうかを指定します。`False` に設定されている場合、設定されたチェックタイプの前のベースラインが使用可能である必要があります。
+ `register_new_baseline`: このパラメータでは、新しく計算されたベースラインにステッププロパティ `BaselineUsedForDriftCheckConstraints` を通じてアクセスできるかどうかを指定します。`False` に設定されている場合、設定されたチェックタイプの前のベースラインも使用可能である必要があります。このベースラインには `BaselineUsedForDriftCheckConstraints` プロパティを通じてアクセスできます。
詳細については、「[Amazon SageMaker Pipelines の ClarifyCheck と QualityCheck のステップを使用したベースライン計算、ドリフト検出、ライフサイクル](pipelines-quality-clarify-baseline-lifecycle.md)」を参照してください。
### ベースラインを操作する
必要に応じて、既存のベースラインを検索するために、`model_package_group_name` を指定することもできます。次に、`ClarifyCheck`ステップは、モデルパッケージグループの最新の承認済みモデルパッケージ上の `DriftCheckBaselines` をプルします。
`supplied_baseline_constraints` パラメータを通じて前のベースラインを指定することもできます。`model_package_group_name` と `supplied_baseline_constraints` の両方を指定すると、`ClarifyCheck` ステップでは `supplied_baseline_constraints` パラメータで指定されたベースラインが使用されます。
`ClarifyCheck` ステップを使用する際の要件の詳細については、「*Amazon SageMaker AI SageMaker SDK for Python*」の「[sagemaker.workflow.steps.ClarifyCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.clarify_check_step.ClarifyCheckStep)」を参照してください。Pipelines での `ClarifyCheck` ステップの使用方法を解説した Amazon SageMaker Studio Classic ノートブックについては、「[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 データバイアスチェック用の `ClarifyCheck` ステップを作成する**
```
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 ステップ
`QualityCheck` ステップを使用すると、パイプライン内のデータ品質とモデルの品質についての[ベースラインの提案](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor-create-baseline.html)と以前のベースラインに対するベースラインドリフトチェックを実行できます。次に、`model.register()` メソッドを使用して[ベースラインを生成して登録](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-quality-clarify-baseline-lifecycle.html#pipelines-quality-clarify-baseline-calculations)し、`[step\$1args](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#model-step)` を使用してそのメソッドの出力を [モデルステップ](#step-type-model) に渡すことができます。
Model Monitor では、これらのドリフトチェック用のベースラインをモデルエンドポイントで使用できるため、ベースラインを別途提案する必要がなくなります。`QualityCheck` ステップでは、ドリフトチェック用のベースラインをモデルレジストリからプルすることもできます。`QualityCheck` ステップでは、Amazon SageMaker AI Model Monitor の事前構築済みコンテナを活用します。このコンテナは、制約の提案、統計の生成、ベースラインに対する制約の検証など、さまざまなモデルモニタリング機能を提供します。詳細については、「[Amazon SageMaker Model Monitor のビルド済みコンテナ](model-monitor-pre-built-container.md)」を参照してください。
### QualityCheck ステップを設定する
`QualityCheck` ステップは、パイプラインで使用する都度、以下のチェックタイプのいずれか 1 つのみを実行するように設定できます。
+ データの品質チェック
+ モデルの品質チェック
実行するには、`quality_check_config` パラメータに次のいずれかのチェックタイプ値を指定します。
+ `DataQualityCheckConfig`
+ `ModelQualityCheckConfig`
`QualityCheck` ステップでは、Model Monitor の構築済みコンテナを実行し、チェックと処理ジョブのための専用の設定を必要とする処理ジョブが起動します。`QualityCheckConfig` と `CheckJobConfig`は、これらの設定のヘルパー関数です。これらのヘルパー関数は、Model Monitor がモデルの品質またはデータの品質をモニタリングするためのベースラインの作成方法に合わせて調整されます。Model Monitor のベースラインの提案については、「[ベースラインの作成](model-monitor-create-baseline.md)」と「[モデルの質ベースラインを作成する](model-monitor-model-quality-baseline.md)」を参照してください。
### ドリフトチェックのステップ動作を制御する
`QualityCheck` ステップには、その動作を制御するために、以下の 2 つのブールフラグが必要です。
+ `skip_check`: このパラメータでは、前のベースラインに対するドリフトチェックをスキップするかどうかを指定します。`False` に設定されている場合、設定されたチェックタイプの前のベースラインが使用可能である必要があります。
+ `register_new_baseline`: このパラメータでは、新しく計算されたベースラインにステッププロパティ `BaselineUsedForDriftCheckConstraints` と `BaselineUsedForDriftCheckStatistics` を通じてアクセスできるかどうかを指定します。`False` に設定されている場合、設定されたチェックタイプの前のベースラインも使用可能である必要があります。これらには、`BaselineUsedForDriftCheckConstraints` と `BaselineUsedForDriftCheckStatistics` のプロパティを通じてアクセスできます。
詳細については、「[Amazon SageMaker Pipelines の ClarifyCheck と QualityCheck のステップを使用したベースライン計算、ドリフト検出、ライフサイクル](pipelines-quality-clarify-baseline-lifecycle.md)」を参照してください。
### ベースラインを操作する
`supplied_baseline_statistics` パラメータと `supplied_baseline_constraints` パラメータを使用して、以前のベースラインを直接指定できます。`model_package_group_name` を指定すると、`QualityCheck` ステップは、モデルパッケージグループ内の最新の承認済みモデルパッケージの `DriftCheckBaselines` を取得することもできます。
以下を指定すると、`QualityCheck` ステップは、`QualityCheck` ステップのチェック タイプで `supplied_baseline_constraints` および `supplied_baseline_statistics` によって指定されたベースラインが使用されます。
+ `model_package_group_name`
+ `supplied_baseline_constraints`
+ `supplied_baseline_statistics`
`QualityCheck` ステップを使用する際の要件の詳細については、「*Amazon SageMaker AI SageMaker SDK for Python*」の「[sagemaker.workflow.steps.QualityCheckStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.quality_check_step.QualityCheckStep)」を参照してください。Pipelines での `QualityCheck` ステップの使用方法を解説した Amazon SageMaker Studio Classic ノートブックについては、「[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 データ品質チェックのための `QualityCheck` ステップを作成する**
```
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"
)
```
## EMR ステップ
Amazon SageMaker Pipelines [EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html) ステップを使用して、以下を実行できます。
+ 実行中の Amazon EMR クラスターで [Amazon EMR ステップ](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-work-with-steps.html)を処理します。
+ パイプラインが Amazon EMR クラスターをユーザーの代わりに作成して管理します。
Amazon EMR の詳細については、「[Getting started with Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html)」を参照してください。
EMR ステップでは、`EMRStepConfig` に Amazon EMR クラスターで使用する JAR ファイルの場所と渡す引数を含める必要があります。実行中の EMR クラスターでステップを実行する場合は、Amazon EMR クラスター ID も指定します。クラスターの構成を渡して、自動的に作成、管理、終了されるクラスターで EMR ステップを実行することもできます。以下のセクションには、両方の方法を示す例とサンプルノートブックへのリンクが含まれています。
**注記**
EMR ステップでは、パイプラインに渡すロールに追加のアクセス許可が必要です。[AWS マネージドポリシーをアタッチする: `AmazonSageMakerPipelinesIntegrations`](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol-pipelines.html#security-iam-awsmanpol-AmazonSageMakerPipelinesIntegrations) をパイプラインロールに追加するか、そのポリシーのアクセス許可がロールに含まれていることを確認します。
実行中のクラスターで EMR ステップを処理する場合、使用できるクラスターは以下のいずれかのステータスであるもののみです。
`STARTING`
`BOOTSTRAPPING`
`RUNNING`
`WAITING`
実行中のクラスターで EMR ステップを処理する場合、EMR クラスター上の `PENDING` の状態に最大 256 の EMR ステップを含めることができます。この制限を超えて送信された EMR ステップは、パイプラインの実行に失敗します。[パイプラインのステップの再試行ポリシー](pipelines-retry-policy.md) の使用を検討できます。
クラスター ID またはクラスター設定のいずれかを指定できますが、両方を指定することはできません。
EMR ステップは Amazon EventBridge を利用して EMR ステップまたはクラスターの状態の変化をモニタリングします。実行中のクラスターで Amazon EMR ジョブを処理する場合、EMR ステップは `SageMakerPipelineExecutionEMRStepStatusUpdateRule` ルールを使用して EMR ステップの状態をモニタリングします。EMR ステップが作成したクラスターでジョブを処理する場合、ステップは、`SageMakerPipelineExecutionEMRClusterStatusRule` ルールを使用してクラスターのステータスの変化をモニタリングします。 AWS アカウントにこれらの EventBridge ルールのいずれかが表示された場合は、削除しないでください。削除しないと、EMR ステップが完了しない可能性があります。
**Amazon EMR ステップをパイプラインに追加する**
パイプラインに EMR ステップを追加するには、次の手順を実行します。
+ [Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html)コンソールを開きます。
+ 左側のナビゲーションペインで、**[パイプライン]** を選択します。
+ **[作成]** を選択します。
+ **[指定なし]** をクリックします。
+ 左側のサイドバーで、**[データ処理]** を選択し、キャンバスにドラッグします。
+ キャンバスで、追加した **[データ処理]** ステップを選択します。
+ 右側のサイドバーの モードで、**EMR (マネージド)** を選択します。
+ 右側のサイドバーで、**設定タブと詳細**タブのフォームに入力します。これらのタブのフィールドの詳細については、[「sagemaker.workflow.fail\$1step.EMRstep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.emr_step.EMRStep)」を参照してください。
**実行中の Amazon EMR クラスターで新しいジョブを起動する**
実行中の Amazon EMR クラスターで新しいジョブを起動する場合は、クラスター ID を文字列として `EMRStep` の `cluster_id` 引数に渡します。次の例で、この手順を説明します。
```
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"
)
```
完全な例を説明するサンプルノートブックについては、「[Pipelines EMR Step With Running EMR Cluster](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-running-emr-cluster.ipynb)」を参照してください。
**新しい Amazon EMR クラスターで新しいジョブを起動する**
`EMRStep` が作成した新しいクラスターで新しいジョブを起動するには、クラスターの構成をディクショナリとして指定します。ディクショナリは [RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html) リクエストと同じ構造である必要があります。ただし、以下のフィールドはクラスター設定に含めないでください。
+ [`Name`]
+ [`Steps`]
+ [`AutoTerminationPolicy`]
+ [`Instances`][`KeepJobFlowAliveWhenNoSteps`]
+ [`Instances`][`TerminationProtected`]
その他の `RunJobFlow` 引数はすべて、クラスター設定で使用できます。リクエスト構文の詳細については、「[RunJobFlow](https://docs.aws.amazon.com/emr/latest/APIReference/API_RunJobFlow.html)」を参照してください。
次の例では、クラスターの構成 を EMR ステップ定義に渡します。これにより、ステップは新しい EMR クラスターで新しいジョブを起動するように求められます。この例の EMR クラスター設定には、プライマリー EMR クラスターノードとコア EMR クラスターノードの仕様が含まれています。Amazon EMR ノードタイプの詳細については、「[Understand node types: primary, core, and task nodes](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
)
```
完全な例を説明するサンプルノートブックについては、「[Pipelines EMR Step With Cluster Lifecycle Management](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-pipelines/tabular/emr-step/sagemaker-pipelines-emr-step-with-cluster-lifecycle-management.ipynb)」を参照してください。
## EMR サーバーレスステップ
EMR サーバーレスステップをパイプラインに追加するには、次の手順を実行します。
+ [Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-updated-launch.html)コンソールを開きます。
+ 左側のナビゲーションペインで、**[パイプライン]** を選択します。
+ **[作成]** を選択します。
+ **[指定なし]** をクリックします。
+ 左側のサイドバーで、**[データ処理]** を選択し、キャンバスにドラッグします。
+ キャンバスで、追加した **[データ処理]** ステップを選択します。
+ 右側のサイドバーの モードで、**EMR (サーバーレス)** を選択します。
+ 右側のサイドバーで、**設定タブと詳細**タブのフォームに入力します。
## ノートブックジョブステップ
`NotebookJobStep` を使用して、SageMaker ノートブックジョブをパイプラインステップとして非インタラクティブに実行します。パイプラインを Pipelines のドラッグアンドドロップ UI で構築する場合は、[コードステップを実行する](#step-type-executecode) を使用してノートブックを実行します。SageMaker ノートブックジョブの詳細については、「[SageMaker ノートブックジョブ](notebook-auto-run.md)」を参照してください。
`NotebookJobStep` には、少なくとも入力ノートブック、イメージ URI、カーネル名が必要です。ノートブックジョブステップの要件と、ステップをカスタマイズするために設定できるその他のパラメータの詳細については、「[sagemaker.workflow.steps.NotebookJobStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.notebook_job_step.NotebookJobStep)」を参照してください。
次の例では、最小引数を使用して `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
)
```
`NotebookJobStep` パイプラインステップは、SageMaker ノートブックジョブとして処理されます。このため、`tags` 引数を使用して特定のタグを含めることで、Studio Classic UI ノートブックジョブダッシュボードの実行ステータスを追跡できます。含めるのタグの詳細については、「[Studio UI ダッシュボードでノートブックジョブを表示する](create-notebook-auto-run-sdk.md#create-notebook-auto-run-dash)」を詳細してください。
SageMaker Python SDK を使用してノートブックジョブをスケジュールする場合、ノートブックジョブを実行するために指定できるのは特定のイメージのみです。詳細については、「[SageMaker AI Python SDK ノートブックジョブのイメージに関する制約](notebook-auto-run-constraints.md#notebook-auto-run-constraints-image-sdk)」を参照してください。
## Fail ステップ
目的の条件または状態が達成されなかった場合に、Fail ステップを使用して Amazon SageMaker Pipelines の実行を停止します。Fail ステップを使用すると、パイプラインの実行失敗の原因を示すカスタムエラーメッセージを入力することもできます。
**注記**
Fail ステップとその他のパイプラインステップが同時に実行される場合、すべての同時実行ステップが完了するまでパイプラインは終了しません。
### Fail ステップの使用に関する制限
+ Fail ステップを他のステップの `DependsOn` リストに追加することはできません。詳細については、「[ステップ間のカスタム依存関係](build-and-manage-steps.md#build-and-manage-custom-dependency)」を参照してください。
+ 他のステップは [失敗] ステップを参照できません。それは、*常に*パイプラインの実行の最後のステップです。
+ Fail ステップで終了するパイプライン実行を再試行することはできません。
Fail ステップのエラーメッセージは、静的テキスト文字列の形式で作成できます。別の方法として、[Pipeline パラメータ](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-parameters.html)の [Join](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html?highlight=Join#sagemaker.workflow.functions.Join) オペレーションやその他の[ステップのプロパティ](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-steps.html#build-and-manage-properties)を使用して、より詳細なエラーメッセージを作成することもできます。
------
#### [ Pipeline Designer ]
パイプラインに Fail ステップを追加するには、次の手順を実行します。
1. 「[Amazon SageMaker Studio を起動する](studio-updated-launch.md)」の手順に従って、Studio コンソールを開きます。
1. 左側のナビゲーションペインで、**[パイプライン]** を選択します。
1. **[作成]** を選択します。
1. **[指定なし]** をクリックします。
1. 左側のサイドバーで、**[Fail]** を選択し、キャンバスにドラッグします。
1. キャンバスで、追加した **[Fail]** ステップを選択します。
1. 右側のサイドバーで、**[設定]** タブと **[詳細]** タブのフォームに入力します。これらのタブのフィールドの詳細については、「[sagemaker.workflow.fail\$1step.FailStep](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.fail_step.FailStep)」を参照してください。
1. キャンバスに、追加した **[Fail]** ステップの直前のステップが含まれている場合は、カーソルをクリックして、そのステップから **[Fail]** ステップまでドラッグし、エッジを作成します。
1. キャンバスに、追加した **[Fail]** ステップの直前のステップが含まれている場合は、**[Fail]** ステップからそのステップまでカーソルをクリックしてドラッグし、エッジを作成します。
------
#### [ SageMaker Python SDK ]
**Example**
次のコードスニペット例では、`FailStep` でパイプラインパラメータと `Join` オペレーションで設定した `ErrorMessage` を使用しています。
```
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]
),
)
```
------
# 統合の追加
MLflow 統合を使用すると、パイプラインで MLflow を使用して、追跡サーバーまたはサーバーレスアプリケーションの選択、実験の選択、メトリクスのログ記録を行うことができます。
## 主要なコンセプト
**デフォルトのアプリケーション作成** - パイプラインビジュアルエディタを入力すると、デフォルトの MLflow アプリケーションが作成されます。
**統合パネル** - 新しい統合パネルには、選択して設定できる MLflow が含まれています。
**アプリケーションと実験を更新する** - パイプラインの実行中に選択したアプリケーションと実験を上書きするオプション。
## 仕組み
+ **パイプラインビジュアルエディタ**に移動する
+ ツールバーで**統合**を選択する
+ **MLflow** を選択する
+ MLflow アプリケーションと実験を設定する
## スクリーンショットの例
統合サイドパネル
![\[説明を実行する 。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/screenshot-pipeline-1.png)
MLflow 設定
![\[説明を実行する 。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/screenshot-pipeline-2.png)
パイプラインの実行中に実験を上書きする方法
![\[説明を実行する 。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/screenshot-pipeline-3.png)
## ステップのプロパティ
`properties` 属性は、パイプラインのステップ間にデータの依存関係を追加するために使用されます。Pipelines は、これらのデータ依存関係をパイプライン定義から DAG を構築するために使用します。これらのプロパティはプレースホルダー値として参照でき、実行時に解決されます。
Pipelines ステップの `properties` 属性は、対応する SageMaker AI ジョブタイプに対する `Describe` コールが返すオブジェクトと一致します。ジョブタイプごとに、`Describe` 呼び出しは次のレスポンスオブジェクトを返します。
+ `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)
データ依存関係の作成時に各ステップタイプでどのプロパティが参照可能かを確認するには、「[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable)」の「[Data Dependency - Property Reference](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)」を参照してください。**
## ステップの並列処理
ステップは、他のステップに依存していない場合、パイプライン実行時に直ちに実行されます。ただし、同時に実行するパイプラインステップが多すぎると、使用可能なリソースがすぐに使い果たされる可能性があります。`ParallelismConfiguration` を使用して、パイプラインの同時実行ステップ数を制御します。
次の例では `ParallelismConfiguration` を使用して同時実行ステップの上限数を 5 に設定しています。
```
pipeline.create(
parallelism_config=ParallelismConfiguration(5),
)
```
## ステップ間のデータ依存関係
DAG の構造を定義するには、ステップ間のデータ関係を指定します。ステップ間にデータ依存関係を作成するには、パイプラインのあるステップのプロパティを別のステップに入力として渡します。入力を受け取るステップは、入力を提供するステップの実行が終了するまで開始されません。
データ依存関係は、次の形式の JsonPath 表記で表されます。この形式は JSON プロパティファイルをトラバースします。つまり、ファイル内にネストされた目的のプロパティにアクセスするのに必要な数の ** インスタンスを追加できます。JsonPath 表記の詳細については、「[JsonPath リポジトリ](https://github.com/json-path/JsonPath)」を参照してください。
```
.properties..
```
処理ステップの `ProcessingOutputConfig` プロパティを使用して Amazon S3 バケットを指定する方法を以下に示します。
```
step_process.properties.ProcessingOutputConfig.Outputs["train_data"].S3Output.S3Uri
```
データ依存関係を作成するには、以下のようにバケットをトレーニングステップに渡します。
```
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
))
)
```
データ依存関係の作成時に各ステップタイプでどのプロパティが参照可能かを確認するには、「[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable)」の「[Data Dependency - Property Reference](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#data-dependency-property-reference)」を参照してください。**
## ステップ間のカスタム依存関係
データ依存関係を指定すると、Pipelines がステップ間のデータ接続を提供します。別の方法として、Pipelines を直接使用せずに、あるステップから以前のステップのデータにアクセスすることもできます。この場合、別のステップの実行が終了するまでステップを開始しないように Pipelines に指示するカスタム依存関係を作成できます。カスタム依存関係を作成するには、ステップの`DependsOn` 属性を指定します。
以下の例では、ステップ `A` とステップ `B` の両方が実行を終了してから開始されるステップ `C` を定義します。
```
{
'Steps': [
{'Name':'A', ...},
{'Name':'B', ...},
{'Name':'C', 'DependsOn': ['A', 'B']}
]
}
```
依存関係により循環依存関係が生まれると、Pipelines で検証例外がスローされます。
以下の例では、処理ステップの実行が終了した後に開始されるトレーニングステップを作成します。
```
processing_step = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step])
```
以下の例では、2 つの異なる処理ステップの実行が終了するまで開始されないトレーニングステップを作成します。
```
processing_step_1 = ProcessingStep(...)
processing_step_2 = ProcessingStep(...)
training_step = TrainingStep(...)
training_step.add_depends_on([processing_step_1, processing_step_2])
```
以下は、カスタム依存関係を作成する別の方法です。
```
training_step.add_depends_on([processing_step_1])
training_step.add_depends_on([processing_step_2])
```
以下の例では、ある処理ステップから入力を受け取り、別の処理ステップの実行が終了するまで待機するトレーニングステップを作成します。
```
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])
```
以下の例では、ステップのカスタム依存関係の文字列リストを取得する方法を示しています。
```
custom_dependencies = training_step.depends_on
```
## ステップでのカスタムイメージ
パイプラインでステップを作成する際に利用可能な SageMaker AI の[深層学習コンテナイメージ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md)のいずれかを使用できます。
パイプラインのステップでは独自のコンテナを使用することもできます。Studio Classic 内からイメージを作成することはできないため、Pipelines で使用する前に別の方法でイメージを作成しておく必要があります。
パイプラインのステップの作成時に独自のコンテナを使用する場合は、推定器定義にイメージ URI を追加します。SageMaker AI で独自のコンテナを使用する方法については、「[SageMaker AI で Docker コンテナを使用する](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers.html)」を参照してください。
# @step デコレータを使用した Python コードのリフトアンドシフト
`@step` デコレータは、ローカルの機械学習 (ML) コードを 単一または複数のパイプラインステップに変換する機能です。ML 関数は、他の ML プロジェクトで記述するのと同じ方法で記述できます。ローカルでテストするか、`@remote` デコレータを使用してトレーニングジョブとしてテストを実行した後、`@step` デコレータを追加して関数を SageMaker AI パイプラインステップに変換できます。その後、`@step` デコレータでデコレートされた関数の呼び出しの出力をステップとして Pipelines に渡し、パイプラインを作成して実行できます。`@step` デコレータで一連の関数を連鎖させて、マルチステップの有向非巡回グラフ (DAG) パイプラインを作成することもできます。
`@step` デコレータを使用する設定は、`@remote` デコレータを使用する場合の設定と同じです。[環境をセットアップする](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator.html#train-remote-decorator-env)方法と[設定ファイルを使用](https://docs.aws.amazon.com/sagemaker/latest/dg/train-remote-decorator-config.html)してデフォルトを設定する方法の詳細については、リモート関数のドキュメントを参照してください。`@step` デコレータの詳細については、「[sagemaker.workflow.function\$1step.step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.step)」を参照してください。
`@step` デコレータの使用方法を説明するサンプルノートブックを表示するには、「[@step decorator sample notebooks](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-pipelines/step-decorator)」を参照してください。
以下のセクションでは、`@step` デコレータでローカル ML コードに注釈を付けてステップを作成し、このステップでパイプラインを作成して実行して、ユースケースのエクスペリエンスをカスタマイズする方法について説明します。
**Topics**
+ [`@step` でデコレートした関数を使用してパイプラインを作成する](pipelines-step-decorator-create-pipeline.md)
+ [パイプラインを実行する](pipelines-step-decorator-run-pipeline.md)
+ [パイプラインを設定する](pipelines-step-decorator-cfg-pipeline.md)
+ [ベストプラクティス](pipelines-step-decorator-best.md)
+ [制限事項](pipelines-step-decorator-limit.md)
# `@step` でデコレートした関数を使用してパイプラインを作成する
`@step` デコレータを使用して Python 関数をパイプラインステップに変換し、それらの関数間に依存関係を作成してパイプライングラフ (または有向非巡回グラフ (DAG)) を作成して、このグラフのリーフノードをステップのリストとしてパイプラインに渡すことで、パイプラインを作成できます。以下のセクションでは、この手順を例を使って詳しく説明します。
**Topics**
+ [関数をステップに変換する](#pipelines-step-decorator-run-pipeline-convert)
+ [ステップ間の依存関係を作成する](#pipelines-step-decorator-run-pipeline-link)
+ [`@step` でデコレートしたステップで `ConditionStep` でを使用する](#pipelines-step-decorator-condition)
+ [ステップの `DelayedReturn` 出力を使用してパイプラインを定義する](#pipelines-step-define-delayed)
+ [パイプラインを作成する](#pipelines-step-decorator-pipeline-create)
## 関数をステップに変換する
`@step` デコレータを使用してステップを作成するには、`@step` 関数を使用して注釈を付けます。次の例は、データを事前処理する `@step` でデコレートした関数を説明しています。
```
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)
```
`@step` でデコレートした関数を呼び出すと、SageMaker AI は関数を実行する代わりに `DelayedReturn` インスタンスを返します。`DelayedReturn` インスタンスは、その関数の実際の戻り値のプロキシです。`DelayedReturn` インスタンスは、別の関数に引数として渡すことも、ステップとしてパイプラインインスタンスに直接渡すこともできます。`DelayedReturn` クラスの詳細については、「[sagemaker.workflow.function\$1step.DelayedReturn](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.function_step.DelayedReturn)」を参照してください。
## ステップ間の依存関係を作成する
2 つのステップ間に依存関係を作成する際は、パイプライングラフのステップ間に接続を作成します。以下のセクションでは、パイプラインステップ間の依存関係を作成する複数の方法を紹介します。
### 入力引数を使用したデータ依存関係
ある関数の `DelayedReturn` 出力を別の関数への入力として渡すと、パイプライン DAG にデータ依存関係が自動的に作成されます。次の例では、`preprocess` 関数の `DelayedReturn` 出力を `train` 関数に渡す `preprocess` と、`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)
```
前の例では、`@step` でデコレートされたトレーニング関数を定義しています。この関数が呼び出されると、前処理パイプラインステップの `DelayedReturn` 出力を入力として受け取ります。トレーニング関数を呼び出すと、別の `DelayedReturn` インスタンスが返されます。このインスタンスは、パイプライン DAG を形成する、その関数で定義された以前のすべてのステップ (この例の `preprocess` ステップ) に関する情報を保持します。
前の例では、`preprocess` 関数は単一の値を返します。リストやタプルなどのより複雑な戻り値タイプについては、「[制限事項](pipelines-step-decorator-limit.md)」を参照してください。
### カスタム依存関係を定義する
前の例では、`train` 関数は `preprocess` の `DelayedReturn` 出力を受け取り、依存関係を作成しました。前のステップの出力を渡さずに依存関係を明示的に定義する場合は、`add_depends_on` 関数をステップで使用します。`get_step()` 関数を使用して、その `DelayedReturn` インスタンスから基盤となるステップを取得し、依存関係を入力として `add_depends_on`\$1on を呼び出します。`get_step()` 関数の定義を表示するには、「[sagemaker.workflow.step\$1outputs.get\$1step](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.step_outputs.get_step)」を参照してください。次の例は、`get_step()` と `add_depends_on()` を使用して、`preprocess` と `train` の依存関係を作成する方法を説明しています。
```
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])
```
### `@step` でデコレートした関数から従来のパイプラインステップにデータを渡す
`@step` でデコレートしたステップと従来のパイプラインステップを含むパイプラインを作成し、両者間でデータを渡すパイプラインを作成できます。例えば、`ProcessingStep` を使用してデータを処理し、その結果を `@step` でデコレートしたトレーニング関数に渡すことができます。次の例では、`@step` でデコレートしたトレーニングステップは、処理ステップの出力を参照します。
```
# 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,
)
```
## `@step` でデコレートしたステップで `ConditionStep` でを使用する
Pipelines は、先行するステップの結果を評価してパイプラインで実行するアクションを決定する、`ConditionStep` クラスをサポートしています。`ConditionStep` は、`@step` でデコレートしたステップでも使用できます。`ConditionStep` で任意の `@step` でデコレートしたステップの出力を使用するには、そのステップの出力を `ConditionStep` の引数として入力します。次の例の条件ステップは、`@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()],
)
```
## ステップの `DelayedReturn` 出力を使用してパイプラインを定義する
パイプラインの定義方法は、`@step` デコレータを使用する場合も使用しない場合も同じです。`DelayedReturn` インスタンスをパイプラインに渡す場合、パイプラインを構築するためのステップの完全なリストを渡す必要はありません。SDK は、定義した依存関係に基づいて前のステップを自動的に推測します。パイプラインに渡した `Step` オブジェクトまたは `DelayedReturn` オブジェクトの前のすべてのステップすべてがパイプライングラフに含まれます。次の例では、パイプラインは `train` 関数の `DelayedReturn` オブジェクトを受け取ります。SageMaker AI は、`preprocess` ステップを `train` の前のステップとしてパイプライングラフに追加します。
```
from sagemaker.workflow.pipeline import Pipeline
pipeline = Pipeline(
name="",
steps=[step_train_result],
sagemaker_session=,
)
```
ステップ間にデータやカスタム依存関係がなく、複数のステップを並行して実行する場合、パイプライングラフには複数のリーフノードが含まれます。このようなリーフノードをすべてリストにして、パイプライン定義の `steps` 引数に渡します。
```
@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,
)
```
パイプラインを実行すると、両方のステップが並行して実行されます。
リーフノードには、データまたはカスタム依存関係を通じて定義された以前のすべてのステップに関する情報が含まれているため、パイプラインに渡すのはグラフのリーフノードのみです。パイプラインをコンパイルすると、SageMaker AI はパイプライングラフを形成する後続のすべてのステップも推測し、それぞれを個別のステップとしてパイプラインに追加します。
## パイプラインを作成する
次のスニペットに示されるとおり、`pipeline.create()` を呼び出してパイプラインを作成します。`create()` の詳細については、「[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)
```
`pipeline.create()` を呼び出すと、SageMaker AI はパイプラインインスタンスの一部として定義されたすべてのステップをコンパイルします。SageMaker AI は、シリアル化された関数、引数、その他のすべてのステップ関連のアーティファクトを Amazon S3 にアップロードします。
データは、次の構造に従って S3 バケットに存在します。
```
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` は、SageMaker AI 設定ファイルで定義され、パイプライン全体にわたって適用されます。定義されていない場合は、デフォルトの SageMaker AI バケットが使用されます。
**注記**
SageMaker AI がパイプラインをコンパイルする都度、SageMaker AI はステップのシリアル化された関数、引数、依存関係をその時点の時刻でタイムスタンプされたフォルダに保存します。これは、`pipeline.create()`、`pipeline.update()`、`pipeline.upsert()` または `pipeline.definition()` を実行する都度、発生します。
# パイプラインを実行する
次のページでは、Amazon SageMaker Pipelines を使用して、SageMaker AI リソースで、またはローカルでパイプラインを実行する方法について説明します。
従来の SageMaker AI パイプライン実行と同様に、`pipeline.start()` 関数を使用して新しいパイプライン実行を開始します。`start()` 関数の詳細については、「[sagemaker.workflow.pipeline.Pipeline.start](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline.Pipeline.start)」を参照してください。
**注記**
`@step` デコレータを使用して定義したステップは、トレーニングジョブとして実行されます。そのため、次の制限について注意が必要です。
アカウントにはインスタンス制限とトレーニングジョブ制限があります。スロットリングやリソース制限の問題を避けるため、制限を更新します。
パイプライン内では、トレーニングステップの実行ごとに発生する金銭的コストが発生します。料金の詳細については、「[Amazon SageMaker の料金](https://aws.amazon.com/sagemaker/pricing/)」を参照してください。
## ローカルで実行されたパイプラインから結果を取得する
パイプライン実行の任意のステップの結果を表示するには、次のスニペットに示されるとおり、[execution.result()](https://sagemaker.readthedocs.io/en/stable/workflows/pipelines/sagemaker.workflow.pipelines.html#sagemaker.workflow.pipeline._PipelineExecution.result ) を使用します。
```
execution = pipeline.start()
execution.result(step_name="train")
```
**注記**
Pipelines は、ローカルモードでの `execution.result()` はサポートしていません。
一度に取得できるのは、単一のステップの結果のみです。SageMaker AI が生成したステップ名の場合は、次のとおり `list_steps` を呼び出してステップ名を取得できます。
```
execution.list_step()
```
## パイプラインをローカルで実行する
`@step` でデコレートしたステップを含むパイプラインは、従来のパイプラインステップと同様にローカルで実行できます。ローカル モードのパイプライン実行の詳細については、「[ローカルモードを使用してパイプラインを実行する](pipelines-local-mode.md)」を参照してください。ローカルモードを使用するには、次の例に示されるとおり、パイプライン定義に `SageMakerSession` ではなく、`LocalPipelineSession` を指定します。
```
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()
```
# パイプラインを設定する
パイプラインのデフォルトを設定するには、SageMaker AI 設定ファイルを使用することをお勧めします。SageMaker AI 設定ファイルの詳細については、「[SageMaker Python SDK を使用してデフォルトを設定して使用する](https://sagemaker.readthedocs.io/en/stable/overview.html#configuring-and-using-defaults-with-the-sagemaker-python-sdk)」を参照してください。設定ファイルに追加された設定は、パイプライン内のすべてのステップに適用されます。いずれかのステップのオプションを上書きする場合は、`@step` デコレータ引数に新しい値を指定します。次のトピックでは、設定ファイルをセットアップする方法について説明します。
設定ファイル内の `@step` デコレータの設定は、`@remote` デコレータの設定と同じです。設定ファイルでパイプラインロール ARN とパイプラインタグを設定するには、次のスニペットのとおり `Pipeline` セクションを使用します。
```
SchemaVersion: '1.0'
SageMaker:
Pipeline:
RoleArn: 'arn:aws:iam::555555555555:role/IMRole'
Tags:
- Key: 'tag_key'
Value: 'tag_value'
```
設定ファイルで指定できるデフォルトのほとんどは、`@step` デコレータに新しい値を渡すことでオーバーライドすることもできます。例えば、次の例に示されるとおり、前処理ステップの設定ファイルで指定されたインスタンスタイプを上書きできます。
```
@step(instance_type="ml.m5.large")
def preprocess(raw_data):
df = pandas.read_csv(raw_data)
...
return procesed_dataframe
```
引数によっては、`@step` デコレータパラメータリストに含まれていません。このような引数は、SageMaker AI 設定ファイルを介してのみパイプライン全体に対して設定できます。このような因数は、以下のとおりです。
+ `sagemaker_session` (`sagemaker.session.Session`): SageMaker AI がサービスコールを委任する基盤となる SageMaker AI セッション。指定しない場合は、以下のデフォルト設定を使用してセッションが作成されます。
```
SageMaker:
PythonSDK:
Modules:
Session:
DefaultS3Bucket: 'default_s3_bucket'
DefaultS3ObjectKeyPrefix: 'key_prefix'
```
+ `custom_file_filter` (`CustomFileFilter)`: パイプラインステップに含めるローカルディレクトリとファイルを指定する `CustomFileFilter` オブジェクト。指定しない場合、この値はデフォルトで `None` になります。`custom_file_filter` を有効にするには、`IncludeLocalWorkdir` を `True` に設定する必要があります。次の例は、すべてのノートブックファイル、`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"
```
`CustomFileFilter` で `IncludeLocalWorkdir` を使用する方法の詳細については、「[モジュラーコードと @remote デコレータの使用](train-remote-decorator-modular.md)」を詳細してください。
+ `s3_root_uri (str)`: SageMaker AI がコードアーカイブとデータをアップロードするルート Amazon S3 フォルダ。指定しない場合は、デフォルトの SageMaker AI バケットが使用されます。
+ `s3_kms_key (str)`: 入出力データの暗号化に使用されるキー。この引数は SageMaker AI 設定ファイルでのみ設定でき、この引数はパイプラインで定義されるすべてのステップに適用されます。指定しない場合、値はデフォルトで `None` になります。S3 KMS キー設定の例については、次のスニペットを参照してください。
```
SchemaVersion: '1.0'
SageMaker:
PythonSDK:
Modules:
RemoteFunction:
S3KmsKeyId: 's3kmskeyid'
S3RootUri: 's3://amzn-s3-demo-bucket/my-project
```
# ベストプラクティス
以降のセクションでは、パイプラインステップに`@step` デコレータを使用する際に従うべきベストプラクティスを提案しています。
## ウォームプールを使用する
パイプライン ステップの実行を高速化するには、トレーニングジョブ用に提供されているウォームプール機能を使用します。次のスニペットに示されるとおり、`@step` デコレータに `keep_alive_period_in_seconds` 引数を指定することで、ウォームプール機能を有効にできます。
```
@step(
keep_alive_period_in_seconds=900
)
```
ウォームプールの詳細については、「[SageMaker AI マネージドウォームプール](train-warm-pools.md)」を参照してください。
## ディレクトリを構造化する
`@step` デコレータを使用する際は、コードモジュールを使用することをお勧めします。ステップ関数を呼び出してパイプラインを定義する `pipeline.py` モジュールをワークスペースのルートに配置します。推奨される構造は、以下のとおりです。
```
.
├── 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/
```
# 制限事項
以降のセクションでは、パイプラインステップに `@step` デコレータを使用する際に注意すべき制限事項について説明します。
## 関数引数の制限
`@step` でデコレートした関数に入力引数を渡すと、以下の制限が適用されます。
+ `DelayedReturn` オブジェクト、(他のタイプのステップの) `Properties` オブジェクト、`Parameter`、`ExecutionVariable` オブジェクトを、`@step` でデコレートした関数に引数として渡すことができます。ただし、`@step` でデコレートした関数は引数としての `JsonGet` オブジェクトと `Join` オブジェクトをサポートしていません。
+ `@step` 関数からパイプライン変数に直接アクセスすることはできません。以下の例ではエラーが発生します。
```
param = ParameterInteger(name="", default_value=10)
@step
def func():
print(param)
func() # this raises a SerializationError
```
+ パイプライン変数を別のオブジェクトにネストして、`@step` 関数に渡すことはできません 以下の例ではエラーが発生します。
```
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
```
+ 関数の入力と出力はシリアル化されるため、関数からの入出力として渡すことができるデータのタイプには制限があります。詳細については、「[リモート関数を呼び出す](train-remote-decorator-invocation.md)」の「*Data serialization and deserialization*」セクションを参照してください。`@step` でデコレートした関数にも同じ制限が適用されます。
+ boto クライアントを持つオブジェクトはシリアル化できないため、`@step` でデコレートした関数への入出力としてこのようなオブジェクトを渡すことはできません。例えば、`Estimator`、`Predictor`、`Processor` などの SageMaker Python SDK クライアントクラスはシリアル化できません。
## 関数のインポート
ステップに必要なライブラリは、関数の外部に配置するのではなく内部にインポートする必要があります。グローバルスコープでインポートすると、関数をシリアル化する際にインポートの衝突が発生するリスクがあります。例えば、`sklearn.pipeline.Pipeline` は `sagemaker.workflow.pipeline.Pipeline` に上書きされる可能性があります。
## 関数の戻り値の子メンバーの参照
`@step` でデコレートした関数の戻り値の子メンバーを参照する場合、以下の制限が適用されます。
+ `DelayedReturn` オブジェクトがタプル、リスト、またはディクトである場合は、次の例に示されるとおり、子メンバーを `[]` で参照できます。
```
delayed_return[0]
delayed_return["a_key"]
delayed_return[1]["a_key"]
```
+ 関数を呼び出す際に基となるタプルまたはリストの正確な長さが不明であるため、タプルの出力またはリストの出力はアンパックできません。以下の例ではエラーが発生します。
```
a, b, c = func() # this raises ValueError
```
+ `DelayedReturn` オブジェクトを反復処理することはできません。以下の例ではエラーが発生します。
```
for item in func(): # this raises a NotImplementedError
```
+ 任意の子メンバーを '`.`' で参照することはできません。以下の例ではエラーが発生します。
```
delayed_return.a_child # raises AttributeError
```
## サポートされていない既存のパイプライン機能
`@step` デコレータは、以下のパイプライン機能では使用できません。
+ [Pipeline ステップのキャッシュ](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines-caching.html)
+ [プロパティファイル](https://docs.aws.amazon.com/sagemaker/latest/dg/build-and-manage-propertyfile.html#build-and-manage-propertyfile-property)
# ステップ間でデータを渡す
Amazon SageMaker Pipelines を使用してパイプラインを構築する場合は、あるステップから次のステップにデータを渡す必要がある場合があります。例えば、トレーニングステップが生成したモデルアーティファクトをモデル評価ステップまたはデプロイステップへの入力として使用する必要がある場合があります。この機能を使用すると、相互依存パイプラインステップを作成して、ML ワークフローを構築できます。
パイプラインステップの出力から情報を取得する必要がある場合は、`JsonGet` を使用できます。`JsonGet` は、Amazon S3 またはプロパティファイルから情報を抽出するのに役立ちます。以降のセクションでは、`JsonGet` を使用してステップ出力を抽出するために利用できる方法について説明します。
## Amazon S3 を使用してステップ間でデータを渡す
`ConditionStep` で `JsonGet` を使用すると、Amazon S3 から直接 JSON 出力を取得できます。Amazon S3 URI は、プリミティブ文字列、パイプライン実行変数、またはパイプラインパラメータを含む `Std:Join` 関数にすることができます。以下の例は、`ConditionStep` で `JsonGet` を使用する方法を説明しています。
```
# 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
)
```
条件ステップで Amazon S3 パスを使用して `JsonGet` を使用する場合は、条件ステップと JSON 出力を生成するステップの間に依存関係を明示的に追加する必要があります。次の例では、条件ステップが処理ステップへの依存関係を持つように作成されています。
```
cond_step = ConditionStep(
name="",
conditions=[cond_lte],
if_steps=[fail_step],
else_steps=[register_model_step],
depends_on=[processing_step],
)
```
## プロパティファイルを使用してステップ間でデータを渡す
プロパティファイルを使用して、処理ステップの出力の情報を保存します。これは、処理ステップの結果を分析して、条件ステップの実行方法を決定するために特に便利です。`JsonGet` 関数はプロパティファイルを処理し、JsonPath 表記を使用してプロパティ JSON ファイルをクエリできるようにします。JsonPath 表記の詳細については、「[JsonPath リポジトリ](https://github.com/json-path/JsonPath)」を参照してください。
後で使用できるようにプロパティファイルを保存するには、最初に `PropertyFile` インスタンスを以下の形式で作成する必要があります。`path` パラメータは、プロパティファイルが保存される JSON ファイルの名前です。いずれの `output_name` も、処理ステップで定義した `ProcessingOutput` の `output_name` と一致する必要があります。これにより、ステップの `ProcessingOutput` をプロパティファイルでキャプチャできるようになります。
```
from sagemaker.workflow.properties import PropertyFile
= PropertyFile(
name="",
output_name="",
path=""
)
```
`ProcessingStep` インスタンスを作成する際に、`property_files` パラメータを追加して、Amazon SageMaker Pipelines サービスがインデックスを作成する必要があるすべてのパラメータファイルをリストします。これにより、プロパティファイルが保存され、後で使用できるようになります。
```
property_files=[]
```
条件ステップでプロパティファイルを使用するには、次の例に示すように、条件ステップに渡す条件に `property_file` を追加し、`json_path` パラメータを使用して JSON ファイルで目的のプロパティをクエリします。
```
cond_lte = ConditionLessThanOrEqualTo(
left=JsonGet(
step_name=step_eval.name,
property_file=,
json_path="mse"
),
right=6.0
)
```
より詳細な例については、「[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable)」の「[Property File](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_model_building_pipeline.html#property-file)」を参照してください。**
# パイプラインのステップのキャッシュ
Amazon SageMaker Pipelines では、ステップのキャッシュを使用して、パイプラインを再実行する際の時間とリソースを節約できます。ステップのキャッシュは、ステップの設定と入力が同じである場合、(再計算せずに) ステップの以前正常に完了した実行の出力を再利用します。これにより、同一のパラメータでパイプラインを再実行しても一貫した結果が得られるようになります。次のトピックでは、パイプラインステップのキャッシュを設定して有効にする方法について説明します。
ステップの署名付きキャッシュを使用すると、Pipelines は、特定の属性の値が同一である現在のパイプラインステップの以前の実行を検索します。見つかった場合、Pipelines はステップを再計算するのではなく、前回の実行からの出力を伝搬します。チェックされる属性はステップタイプに固有のもので、[パイプラインステップタイプ別のデフォルトのキャッシュキー属性](pipelines-default-keys.md) にリストされています。
ステップのキャッシュをオプトインする必要があります。デフォルトではオフになっています。ステップのキャッシュをオンにするときは、タイムアウトも定義する必要があります。このタイムアウトは、前回の実行時間からどのくらい経っても再利用の候補として残せるのかを定義します。
ステップキャッシュは実行の成功のみを考慮します。失敗した実行を再利用することはありません。タイムアウト期間内に複数の成功した実行が存在する場合、Pipelines は最新の正常に完了した実行の結果を使用します。一致する正常に完了した実行がタイムアウト期間内にない場合、Pipelines はステップを再実行します。エグゼキュターが条件を満たすが進行中である以前の実行を検出した場合、両方のステップは実行を継続し、成功すればキャッシュを更新します。
ステップのキャッシュでは個々のパイプラインのみが対象となるため、ステップ署名が一致しても別のパイプラインのステップを再利用することはできません。
ステップのキャッシュは、次のステップタイプに使用できます。
+ [Processing](build-and-manage-steps-types.md#step-type-processing)
+ [トレーニング](build-and-manage-steps-types.md#step-type-training)
+ [チューニング](build-and-manage-steps-types.md#step-type-tuning)
+ [AutoML](build-and-manage-steps-types.md#step-type-automl)
+ [変換](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**
+ [ステップキャッシュを有効にする](pipelines-caching-enabling.md)
+ [ステップキャッシュを無効にする](pipelines-caching-disabling.md)
+ [パイプラインステップタイプ別のデフォルトのキャッシュキー属性](pipelines-default-keys.md)
+ [キャッシュデータアクセス制御](pipelines-access-control.md)
# ステップキャッシュを有効にする
ステップのキャッシュを有効にするには、ステップ定義に `CacheConfig` プロパティを追加する必要があります。 `CacheConfig` プロパティはパイプライン定義ファイルで次の形式を使用します。
```
{
"CacheConfig": {
"Enabled": false,
"ExpireAfter": "