翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# 推論のためのモデルをデプロイする
Amazon SageMaker AI を使用すると、トレーニングされた機械学習モデルから予測または*推論*の取得を開始できます。SageMaker AI の広範な ML インフラストラクチャとモデルデプロイオプションは、ML 推論のあらゆるニーズを満たすのに役立ちます。SageMaker AI Inference を使用すると、モデルのデプロイメントをスケーリングし、本番環境でモデルをより効果的に管理して、運用上の負担を軽減できます。SageMaker AI には、低遅延推論を取得するためのリアルタイムエンドポイント、フルマネージドインフラストラクチャと自動スケーリング用のサーバーレスエンドポイント、リクエストのバッチ用の非同期エンドポイントなど、さまざまな推論オプションが用意されています。ユースケースに適した推論オプションを活用することで、効率的なモデルのデプロイと推論を確保できます。
## 機能を選択する
SageMaker AI を使用して ML モデルをデプロイする際、いくつかのユースケースがあります。このセクションでは、これらのユースケースと、ユースケースごとに推奨される SageMaker AI の機能について説明します。
### ユースケース
SageMaker AI を使用して ML モデルをデプロイする主なユースケースを次に示します。
+ **ユースケース 1: 機械学習モデルをローコード環境またはノーコード環境にデプロイする。**初心者や SageMaker AI を初めて使用するユーザーが、Amazon SageMaker Studio インターフェイスを介して Amazon SageMaker JumpStart を使用して、トレーニング済みのモデルをデプロイできます。複雑な設定は必要ありません。
+ **ユースケース 2: コードを使用して、より柔軟性と制御性に優れた機械学習モデルをデプロイする。**経験豊富な ML プラクティショナーは、SageMaker AI Python SDK の `ModelBuilder` クラスを使用して、アプリケーションニーズに合わせてカスタマイズされた設定で独自のモデルをデプロイできます。これにより、インスタンスタイプ、ネットワーク分離、リソース割り当てなど、さまざまな設定をきめ細かく制御できます。
+ **ユースケース 3: 機械学習モデルを大規模にデプロイする。**本番環境でモデルを大規模に管理したい上級ユーザーや組織の場合は、 AWS SDK for Python (Boto3) と を、必要な Infrastructure as Code (IaC) および CI/CD ツール CloudFormation とともに使用して、リソースをプロビジョニングし、リソース管理を自動化します。
### 推奨機能
次の表は、各ユースケースに対応する SageMaker AI 機能の主な考慮事項とトレードオフを示しています。
| | ユースケース 1 | ユースケース 2 | ユースケース 3 |
| --- | --- | --- | --- |
| SageMaker AI の機能 | [Studio の JumpStart](jumpstart-foundation-models-use-studio-updated.md) を使用して、基本モデルのデプロイを高速化します。 | [SageMaker Python SDK の ModelBuilder](how-it-works-modelbuilder-creation.md) を使用してモデルをデプロイします。 | を使用してモデルを[大規模にデプロイおよび管理します CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_SageMaker.html)。 |
| 説明 | Studio UI を使用して、事前にトレーニングされたモデルをカタログから事前設定済みの推論エンドポイントにデプロイします。このオプションは、市民データサイエンティストや、複雑な設定を行わずにモデルをデプロイしたいユーザーに最適です。 | Amazon SageMaker AI Python SDK の ModelBuilder クラスを使用して、独自のモデルをデプロイし、デプロイ設定を構成します。このオプションは、経験豊富なデータサイエンティストや、独自のモデルをデプロイして、きめ細かな制御を行う必要があるすべてのユーザーに最適です。 | CloudFormation および Infrastructure as Code (IaC) を使用して、SageMaker AI モデルをデプロイおよび管理するためのプログラムによる制御と自動化を行います。このオプションは、一貫性のある反復可能なデプロイを必要とする上級ユーザーに最適です。 |
| 最適化の対象 | 一般的なオープンソースモデルの迅速で、効率的なデプロイ | 独自のモデルのデプロイ | 本番環境でのモデルの継続的な管理 |
| 考慮事項 | コンテナ設定と特定のアプリケーションのニーズに対するカスタマイズの欠如 | UI を使用できない。Python コードの開発と保守に慣れている必要があります | インフラストラクチャ管理と組織リソースが必要であり、 AWS SDK for Python (Boto3) または CloudFormation テンプレートに精通している必要があります。 |
| 推奨環境 | SageMaker AI ドメイン | AWS 認証情報と SageMaker Python SDK がインストールされている Python 開発環境、または [SageMaker JupyterLab](studio-updated-jl.md) などの SageMaker AI IDE。 | AWS CLI、ローカル開発環境、Infrastructure as Code (IaC) および CI/CD ツール |
### 追加オプション
SageMaker AI には推論のユースケース向けにさまざまなオプションが用意されており、デプロイの技術的な幅と深さを選択できます。
+ **エンドポイントにモデルをデプロイする。**モデルをデプロイするときは、次のオプションを検討します。
+ [リアルタイム推論](realtime-endpoints.md)。リアルタイム推論は、インタラクティブで低レイテンシーの要件がある推論ワークロードに最適です。
+ [Amazon SageMaker Serverless Inference を使用してモデルをデプロイする](serverless-endpoints.md)。サーバーレス推論を使用して、基盤となるインフラストラクチャのいずれも設定または管理せずにモデルをデプロイします。このオプションは、トラフィックのスパート間にアイドル期間があり、コールドスタートを許容できるワークロードに最適です。
+ [非同期推論](async-inference.md)。受信した推論リクエストをキューに入れて非同期に処理します。このオプションは、ペイロードサイズが大きく (最大 1 GB)、処理時間が長い (最大 1 時間)、ほぼリアルタイムのレイテンシー要件があるリクエストに最適です。
+ **コスト最適化。**推論コストを最適化するには、次のオプションを検討します。
+ [SageMaker Neo によるモデルパフォーマンスの最適化](neo.md)。 SageMaker Neo を使用すると、機械学習モデルをより優れたパフォーマンスと効率で最適化して実行できるため、Inferentia AWS チップなどの環境で実行するようにモデルを自動的に最適化することで、コンピューティングコストを最小限に抑えることができます。
+ [Amazon SageMaker AI モデルの自動スケーリング](endpoint-auto-scaling.md)。自動スケーリングを使用して、受信トラフィックパターンに基づいてエンドポイントのコンピューティングリソースを動的に調整します。これにより、特定の時間に使用するリソースに対してのみ料金を支払うことが可能になり、コストを最適化できます。
# Amazon SageMaker AI のモデルデプロイオプション
機械学習モデルをトレーニングした後、Amazon SageMaker AI を使用してデプロイし、予測を取得できます。Amazon SageMaker AI では、ユースケースに応じて、以下の方法でモデルをデプロイできます。
+ 一度に 1 つの予測を行う永続的なリアルタイムエンドポイントの場合は、SageMaker AI リアルタイムホスティングサービスを使用します。「[リアルタイム推論](realtime-endpoints.md)」を参照してください。
+ トラフィックのスパイク間にアイドル期間があり、コールドスタートを許容できるワークロードは、サーバーレス推論を使用します。「[Amazon SageMaker Serverless Inference を使用してモデルをデプロイする](serverless-endpoints.md)」を参照してください。
+ 1 GB までの大きなペイロードサイズ、長い処理時間、ほぼリアルタイムのレイテンシー要件を持つリクエストでは、Amazon SageMaker 非同期推論を使用します。「[非同期推論](async-inference.md)」を参照してください。
+ データセット全体の予測を取得するには、SageMaker AI のバッチ変換を使用します。「[Amazon SageMaker AI による推論のためのバッチ変換](batch-transform.md)」を参照してください。
SageMaker AI は、機械学習モデルをデプロイする際にリソースを管理し、推論性能を最適化する機能も提供します。
+ エッジデバイスのフリートで機械学習モデルを最適化、保護、モニタリング、保守できるようにエッジデバイス上のモデルを管理するには、「[SageMaker Edge Manager を使用したエッジでのモデルのデプロイ](edge.md)」を参照してください。これは、スマートカメラ、ロボット、パーソナルコンピュータ、モバイルデバイスなどのエッジデバイスに適用されます。
+ Ambarella、ARM、Intel、Nvidia、NXP、Qualcomm、Texas Instruments、Xilinx のプロセッサをベースとする Android、Linux、Windows マシンで推論を行うために、Gluon、Keras、MXNet、PyTorch、TensorFlow-Lite、ONNX モデルを最適化するには、「[SageMaker Neo によるモデルパフォーマンスの最適化](neo.md)」を参照してください。
これらすべてのデプロイオプションの詳細については、「[推論のためのモデルをデプロイする](deploy-model.md)」を参照してください。
# Amazon SageMaker AI でモデルをデプロイして推論を取得するためのオプションを理解する
SageMaker AI で推論を始めるには、次のセクションを参照してください。SageMaker AI でモデルをデプロイし、推論を取得するための選択肢について説明しています。「[Amazon SageMaker AI の推論オプション](deploy-model-options.md)」セクションを参考にして、推論のユースケースに最適な機能を判断することができます。
トラブルシューティングや参考情報、使い始めるのに役立つブログや例、よく寄せられるよくある質問については、[リソース](inference-resources.md)セクションを参照してください。
**Topics**
+ [[開始する前に]](#deploy-model-prereqs)
+ [モデルをデプロイするための手順](#deploy-model-steps)
+ [Amazon SageMaker AI の推論オプション](deploy-model-options.md)
+ [Amazon SageMaker AI を使用した推論用の高度なエンドポイントオプション](deploy-model-advanced.md)
+ [Amazon SageMaker AI による推論の次のステップ](deploy-model-next-steps.md)
## [開始する前に]
これらのトピックは、1 つ以上の機械学習モデルを構築およびトレーニングし、それらのモデルをデプロイする準備ができていることを前提としています。SageMaker AI にモデルをデプロイして推論を得るために、SageMaker AI でモデルをトレーニングする必要はありません。独自のモデルがない場合は、SageMaker AI の[組み込みアルゴリズムまたは事前トレーニング済みモデル](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html)を使用することもできます。
SageMaker AI を使用するのが初めてで、まだデプロイするモデルを決めていない場合は、「[Get Started with Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs.html)」チュートリアルの手順を一通り実行してください。このチュートリアルを通じて、SageMaker AI がデータサイエンスプロセスを管理する仕組みや、モデルデプロイを処理する仕組みを理解できます。モデルトレーニングの詳細については、「[モデルのトレーニング](https://docs.aws.amazon.com/sagemaker/latest/dg/train-model.html)」を参照してください。
追加情報、リファレンス、および例については、「[リソース](inference-resources.md)」を参照してください。
## モデルをデプロイするための手順
推論エンドポイントの一般的なワークフローは以下のとおりです。
+ Amazon S3 に保存されているモデルアーティファクトとコンテナイメージを指定して、SageMaker AI Inference でモデルを作成します。
+ 推論オプションを選択します。詳細については、「[Amazon SageMaker AI の推論オプション](deploy-model-options.md)」を参照してください。
+ エンドポイントの背後に必要なインスタンスタイプとインスタンス数を選択して、SageMaker AI Inference エンドポイント設定を作成します。[Amazon SageMaker Inference Recommender](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender.html) を使用すると、インスタンスタイプに関する推奨事項を取得できます。サーバーレス推論の場合は、モデルサイズに基づいて必要なメモリ設定を指定するだけです。
+ SageMaker AI Inference エンドポイントを作成します。
+ エンドポイントを呼び出して、推論をレスポンスとして受け取ります。
次の図は、ここまでのワークフローを示しています。
![\[前の段落で説明したワークフロー。SageMaker AI から推論を取得する方法を示しています。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference-workflow-flowchart.png)
これらのアクションは、 AWS コンソール、 AWS SDKs、SageMaker Python SDK、 CloudFormation または を使用して実行できます AWS CLI。
バッチ変換によるバッチ推論の場合は、モデルアーティファクトと入力データを指定し、バッチ推論ジョブを作成します。SageMaker AI は、推論用のエンドポイントをホストする代わりに、選択した Amazon S3 の場所に推論結果を出力します。
# Amazon SageMaker AI の推論オプション
SageMaker AI は複数の推論オプションを提供しているため、ワークロードに最適なオプションを選択できます。
+ [リアルタイム推論](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html): **リアルタイム推論は、低レイテンシや高スループットが要求されるオンライン推論に最適です。リアルタイム推論は、選択したインスタンスタイプに基づいて持続的なトラフィックを処理できる、永続的でフルマネージド型のエンドポイント (REST API) に使用します。リアルタイム推論では、最大 25 MB のペイロードサイズと、通常のレスポンスの場合は 60 秒、ストリーミングレスポンスの場合は 8 分の処理時間をサポートできます。
+ [サーバーレス推論](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html): サーバーレス推論は**、断続的またはまれなトラフィックパターンを伴う処理に最適です。SageMaker AI は、基盤となるインフラストラクチャをすべて管理するため、インスタンスやスケーリングポリシーを管理する必要はありません。使用した分のみに課金され、アイドル時間に対する支払いはありません。サーバーレス推論は、最大 4 MB のペイロードサイズと最大 60 秒の処理時間のワークロードに対応できます。
+ [バッチ変換](https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform.html): バッチ変換は**、大量のデータが事前に利用可能で、永続的なエンドポイントが必要ない場合のオフライン処理に適しています。また、データセットの前処理にも使用できます。バッチ変換は、サイズが GB 単位で、処理時間が何日にも及ぶ大規模なデータセットにも対応できます。
+ [非同期推論](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference.html): 非同期推論は**、リクエストをキューに入れる必要がある推論、および大きなペイロードサイズや長時間の処理を要する推論に最適です。非同期推論は、最大 1 GB のペイロードと最大 1 時間の長い処理時間のワークロードに対応できます。処理するリクエストがない場合は、エンドポイントを 0 にスケールダウンすることもできます。
# Amazon SageMaker AI を使用した推論用の高度なエンドポイントオプション
リアルタイム推論では、以下の高度な推論オプションを使用してパフォーマンスとコストをさらに最適化できます。
+ [マルチモデルエンドポイント](multi-model-endpoints.md) – 同じフレームワークを使用するモデルが複数あり、コンテナを共有できる場合は、このオプションを使用します。このオプションは、エンドポイントの利用率を高め、デプロイのオーバーヘッドを減らすことでコストを最適化するのに役立ちます。
+ [マルチコンテナエンドポイント](multi-container-endpoints.md) – 複数のモデルで異なるフレームワークを使用していて、それぞれに独自のコンテナが必要な場合は、このオプションを使用します。マルチモデルエンドポイントの多くの利点を享受でき、さまざまなフレームワークやモデルをデプロイできます。
+ [シリアル推論パイプライン](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) – 前処理と後処理のロジックが組み込まれたモデルをエンドポイントの背後でホストする場合は、このオプションを使用します。推論パイプラインは SageMaker AI によって完全に管理され、すべてのコンテナが同じ Amazon EC2 インスタンスでホストされるため、レイテンシーが低くなります。
# Amazon SageMaker AI による推論の次のステップ
エンドポイントを用意し、一般的な推論ワークフローを理解したら、SageMaker AI の以下の機能を使用して推論ワークフローを改善させることができます。
## モニタリング
モデルの精度やドリフトなどの指標を使用してモデルを時系列的に追跡するには、Model Monitor を使用します。Model Monitor では、モデルの品質に偏差がある場合に通知するアラートを設定できます。詳細については、 [モデルモニタードキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/model-monitor.html)を参照してください。
モデルのデプロイおよびエンドポイントを変更するイベントの監視に使用できるツールの詳細については、「[Monitor Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html)」を参照してください。たとえば、Amazon CloudWatch メトリクスを使用して、呼び出しエラーやモデルレイテンシーなどのメトリクスによりエンドポイントの状態を監視できます。[SageMaker AI エンドポイント呼び出しメトリクス](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation)は、エンドポイントのパフォーマンスに関する貴重な情報を提供できます。
## モデルのデプロイのための CI/CD
SageMaker AI の機械学習ソリューションをまとめるには、[SageMaker AI MLOps](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects.html) を使用します。この機能を使用すると、機械学習ワークフローのステップを自動化して、CI/CD を実践できます。[MLOps プロジェクトテンプレート](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-templates.html)を使用すると、SageMaker AI MLOps プロジェクトのセットアップと実装に役立ちます。SageMaker AI では、CI/CD システムを作成するための独自の[サードパーティ Git リポジトリ](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-projects-walkthrough-3rdgit.html)を使用に対応しています。
ML パイプラインについては、[モデルレジストリ](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry.html)を使用してモデルバージョンとモデルのデプロイと自動化を管理します。
## デプロイガードレール
本番環境に影響を与えずに本番稼働中にモデルを更新する場合、デプロイガードレールを使用できます。デプロイガードレールは、本番環境で機械学習モデルを更新するための SageMaker AI 推論の一連のモデルデプロイオプションです。このフルマネージドデプロイオプションを使うと、本番環境の現在のモデルから新しいモデルへの切り替えをコントロールできます。トラフィックシフトモードを使用すると、トラフィックシフトプロセスをきめ細かく制御できます。また、自動ロールバックなどの組み込みの保護機能により、問題を早期に発見できます。
デプロイガードレールの詳細については、[デプロイガードレールのドキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails.html)を参照してください。
## Inferentia
大規模な機械学習や深層学習のアプリケーションを実行する必要がある場合は、リアルタイムエンドポイントを備えた `Inf1` インスタンスを使用できます。このインスタンスタイプは、画像や音声の認識、自然言語処理 (NLP)、パーソナライゼーション、予測、不正検出などのユースケースに適しています。
`Inf1` インスタンスは、機械学習推論アプリケーションをサポートし、Inferentia チップを搭載するように構築されています。 AWS `Inf1`インスタンスは、GPU ベースのインスタンスよりもスループットが高く、推論あたりのコストが低くなります。
`Inf1` インスタンスにモデルをデプロイするには、SageMaker Neo でモデルをコンパイルし、デプロイオプションとして `Inf1` インスタンスを選択します。詳細については、「[Optimize model performance using SageMaker Neo (SageMaker Neo を使用してモデルのパフォーマンスを最適化する)](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html)」を参照してください。
## モデルパフォーマンスの最適化
SageMaker AI は、機械学習モデルを導入する際にリソースを管理し、推論性能を最適化する機能を提供します。SageMaker AI の[組み込みアルゴリズムおよび構築済みモデル](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html)のほか、機械学習用に開発された構築済みの [Docker イメージ](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-prebuilt.html)も使用できます。
モデルをトレーニングし、デプロイ用に最適化するには、「[Prebuilt Docker images](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-prebuilt.html)」および「[Optimize model performance using SageMaker Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html)」を参照してください。SageMaker Neo では、TensorFlow、Apache MXNet、PyTorch、ONNX、XGBoost のモデルをトレーニングし、最適化して ARM、Intel、および Nvidia プロセッサ上にデプロイできます。
## 自動スケーリング
エンドポイントへのトラフィックの量が変化する場合は、オートスケーリングを試してください。例えば、ピーク時には、リクエストを処理するためにインスタンス数を増やす必要がありますが、トラフィックが少ない時間帯には、コンピューティングリソースの使用を減らしたい場合が考えられます。ワークロードの変動に応じて、プロビジョニングされたインスタンスの数を動的に調整するには、[Amazon SageMaker AI モデルの自動スケーリング](endpoint-auto-scaling.md) を参照してください。
トラフィックパターンを予測できない場合や、スケーリングポリシーを設定しない場合は、エンドポイントに対してサーバーレス推論を使用することもできます。その場合は、SageMaker AI が自動スケーリングを管理します。SageMaker AI は、トラフィックが少ない期間にはエンドポイントをスケールダウンし、トラフィックが増加すると、エンドポイントをスケールアップします。詳細については、[Amazon SageMaker Serverless Inference を使用してモデルをデプロイする](serverless-endpoints.md) ドキュメントを参照してください。
# ModelBuilder を使用して Amazon SageMaker AI でモデルを作成する
SageMaker AI エンドポイントでのデプロイ用にモデルを準備するには、モデルイメージの選択、エンドポイント設定のセットアップ、サーバーとクライアントとの間でデータを転送するためのシリアル化およびシリアル化解除関数のコーディング、モデルの依存関係の特定、Amazon S3 へのアップロードなど、複数のステップが必要です。`ModelBuilder` を使用すると、初期セットアップとデプロイの複雑さを軽減し、デプロイ可能なモデルを 1 つのステップで作成できるようになります。
`ModelBuilder` は以下のタスクを実行します。
+ XGBoost や PyTorch などのさまざまなフレームワークを使用してトレーニングされた機械学習モデルを、1 つのステップでデプロイ可能なモデルに変換します。
+ モデルフレームワークに基づいて自動コンテナ選択を実行します。コンテナを手動で指定する必要はありません。独自の URI を `ModelBuilder` に渡すことで、独自のコンテナを持ち込むことができます。
+ データを推論のためにサーバーに送信する前にクライアント側でのシリアル化の処理、およびサーバーから返された結果の逆シリアル化の処理。データは、手動処理なしで正しくフォーマットされます。
+ 依存関係の自動キャプチャを可能にし、モデルサーバーの想定に従ってモデルをパッケージ化します。`ModelBuilder` の依存関係の自動キャプチャは、依存関係を動的にロードするためのベストエフォートアプローチです。(自動キャプチャをローカルでテストし、ニーズに合わせて依存関係を更新することをお勧めします)。
+ 大規模言語モデル (LLM) のユースケースでは、オプションで、SageMaker AI エンドポイントでホストするときにパフォーマンスを向上させるためにデプロイできる、サービングプロパティのローカルパラメータチューニングを実行します。
+ TorchServe、Triton、DJLServing、TGI コンテナなど、一般的なモデルサーバーとコンテナのほとんどをサポートします。
## ModelBuilder を使用してモデルを構築する
`ModelBuilder` は、XGBoost や PyTorch などのフレームワークモデル、またはユーザーが指定した推論仕様を取得し、デプロイ可能なモデルに変換する Python クラスです。`ModelBuilder` は、デプロイ用のアーティファクトを生成するビルド関数を提供します。生成されたモデルアーティファクトはモデルサーバーに固有であり、入力の 1 つとして指定することもできます。`ModelBuilder` クラスの詳細については、「[ModelBuilder](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.builder.model_builder.ModelBuilder)」を参照してください。
次の図は、`ModelBuilder` を使用する際のモデル作成ワークフロー全体を示しています。`ModelBuilder` は、デプロイ前にローカルでテストできるデプロイ可能なモデルを作成するために、スキーマとともにモデルまたは推論仕様を受け入れます。
![\[ModelBuilder を使用したモデルの作成とデプロイのフロー。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-builder-flow.png)
`ModelBuilder` は、適用するカスタマイズを処理できます。ただし、フレームワークモデルをデプロイするために、モデルビルダーは、少なくとも 1 つのモデル、サンプル入出力、ロールを想定しています。次のコード例では、`ModelBuilder` はフレームワークモデルと最小引数を持つ インスタンス `SchemaBuilder` で呼び出されます (エンドポイントの入出力をシリアル化および逆シリアル化するための対応する関数を推測するため)。コンテナは指定されておらず、パッケージ化された依存関係も渡されません。SageMaker AI はモデルを構築するときにこれらのリソースを自動的に推測します。
```
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
model_builder = ModelBuilder(
model=model,
schema_builder=SchemaBuilder(input, output),
role_arn="execution-role",
)
```
次のコードサンプルは、モデルではなく推論仕様 (`InferenceSpec`インスタンスとして)を持つ `ModelBuilder` を呼び出し、さらにカスタマイズします。この場合、モデルビルダーへの呼び出しには、モデルアーティファクトを保存するパスが含まれ、使用可能なすべての依存関係の自動キャプチャも有効になります。`InferenceSpec` の詳細については、「[モデルのロードとリクエストの処理をカスタマイズする](#how-it-works-modelbuilder-creation-is)」を参照してください。
```
model_builder = ModelBuilder(
mode=Mode.LOCAL_CONTAINER,
model_path=model-artifact-directory,
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(input, output),
role_arn=execution-role,
dependencies={"auto": True}
)
```
## シリアル化と逆シリアル化の方法を定義する
SageMaker AI エンドポイントを呼び出すと、データは異なる MIME タイプの HTTP ペイロードを介して送信されます。例えば、推論のためにエンドポイントに送信されるイメージは、クライアント側でバイトに変換し、HTTP ペイロードを介してエンドポイントに送信する必要があります。エンドポイントがペイロードを受信すると、バイト文字列をモデルが想定するデータタイプに逆シリアル化する必要があります (サーバー側の逆シリアル化とも呼ばれます)。モデルが予測を完了したら、結果も、HTTP ペイロードを介してユーザーまたはクライアントに返送できるバイトにシリアル化する必要があります。クライアントがレスポンスのバイトデータを受信すると、クライアント側で逆シリアル化を実行して、バイトデータを JSON などの想定されるデータ形式に変換する必要があります。少なくとも、以下のデータを変換する必要があります。
1. 推論リクエストのシリアル化 (クライアントによる処理)
1. 推論リクエストの逆シリアル化 (サーバーまたはアルゴリズムによる処理)
1. ペイロードに対してモデルを呼び出し、レスポンスペイロードを送り返す
1. 推論レスポンスのシリアル化 (サーバーまたはアルゴリズムによる処理)
1. 推論レスポンスの逆シリアル化 (クライアントによる処理)
次の図は、エンドポイントを呼び出すときに発生するシリアル化と逆シリアル化のプロセスを示しています。
![\[クライアントからサーバーへのデータのシリアル化と逆シリアル化の図。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-builder-serialization.png)
`SchemaBuilder` にサンプル入出力を指定すると、スキーマビルダーは、入出力をシリアル化および逆シリアル化するための、対応するマーシャリング関数を生成します。`CustomPayloadTranslator` で、シリアル化関数をさらにカスタマイズできます。ただし、ほとんどの場合、次のようなシンプルなシリアライザーで十分です。
```
input = "How is the demo going?"
output = "Comment la démo va-t-elle?"
schema = SchemaBuilder(input, output)
```
`SchemaBuilder` の詳細については、「[SchemaBuilder](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.builder.schema_builder.SchemaBuilder)」を参照してください。
次のコードスニペットは、クライアント側とサーバー側でシリアル化関数と逆シリアル化関数の両方をカスタマイズする例の概要を示しています。`CustomPayloadTranslator` を使用して独自のリクエストとレスポンスのトランスレーターを定義し、これらのトランスレーターを `SchemaBuilder` に渡すことができます。
入力と出力をトランスレーターに含めることで、モデルビルダーはモデルが想定するデータ形式を抽出できます。例えば、サンプル入力が未加工画像であり、カスタムトランスレーターが画像をクロップして、クロップした画像をテンソルとしてサーバーに送信するとします。`ModelBuilder` は、クライアント側とサーバー側の両方でデータを変換する方法を導き出すために、未加工入力とカスタム前処理または後処理コードの両方を必要とします。
```
from sagemaker.serve import CustomPayloadTranslator
# request translator
class MyRequestTranslator(CustomPayloadTranslator):
# This function converts the payload to bytes - happens on client side
def serialize_payload_to_bytes(self, payload: object) -> bytes:
# converts the input payload to bytes
... ...
return //return object as bytes
# This function converts the bytes to payload - happens on server side
def deserialize_payload_from_stream(self, stream) -> object:
# convert bytes to in-memory object
... ...
return //return in-memory object
# response translator
class MyResponseTranslator(CustomPayloadTranslator):
# This function converts the payload to bytes - happens on server side
def serialize_payload_to_bytes(self, payload: object) -> bytes:
# converts the response payload to bytes
... ...
return //return object as bytes
# This function converts the bytes to payload - happens on client side
def deserialize_payload_from_stream(self, stream) -> object:
# convert bytes to in-memory object
... ...
return //return in-memory object
```
次の例に示すように、`SchemaBuilder` オブジェクトを作成するときに、事前に定義されたカスタムトランスレーターとともにサンプル入出力を渡します。
```
my_schema = SchemaBuilder(
sample_input=image,
sample_output=output,
input_translator=MyRequestTranslator(),
output_translator=MyResponseTranslator()
)
```
次に、サンプル入出力を、前に定義したカスタムトランスレーターとともに `SchemaBuilder` オブジェクトに渡します。
```
my_schema = SchemaBuilder(
sample_input=image,
sample_output=output,
input_translator=MyRequestTranslator(),
output_translator=MyResponseTranslator()
)
```
以下のセクションでは、`ModelBuilder` を使用してモデルを構築し、そのサポートクラスを使用してユースケースのエクスペリエンスをカスタマイズする方法について詳しく説明します。
**Topics**
+ [ModelBuilder を使用してモデルを構築する](#how-it-works-modelbuilder-creation-mb)
+ [シリアル化と逆シリアル化の方法を定義する](#how-it-works-modelbuilder-creation-sb)
+ [モデルのロードとリクエストの処理をカスタマイズする](#how-it-works-modelbuilder-creation-is)
+ [モデルの構築とデプロイ](#how-it-works-modelbuilder-creation-deploy)
+ [独自のコンテナ (BYOC)](#how-it-works-modelbuilder-creation-mb-byoc)
+ [ローカルモードで ModelBuilder を使用する](#how-it-works-modelbuilder-creation-local)
+ [ModelBuilder の例](#how-it-works-modelbuilder-creation-example)
## モデルのロードとリクエストの処理をカスタマイズする
`InferenceSpec` を通じて独自の推論コードを指定すると、カスタマイズのレイヤーが追加されます。`InferenceSpec` を使用すると、モデルのロード方法と受信推論リクエストの処理方法をカスタマイズでき、デフォルトのロードと推論処理メカニズムをバイパスできます。この柔軟性は、非標準モデルまたはカスタム推論パイプラインを操作する場合に特に役立ちます。`invoke` メソッドをカスタマイズして、モデルが受信リクエストを前処理および後処理する方法を制御できます。`invoke` メソッドを使用すると、モデルが確実に推論リクエストを正しく処理できます。次の例では、`InferenceSpec` を使用して HuggingFace パイプラインでモデルを生成します。`InferenceSpec` の詳細については、「[InferenceSpec](https://sagemaker.readthedocs.io/en/stable/api/inference/model_builder.html#sagemaker.serve.spec.inference_spec.InferenceSpec)」を参照してください。
```
from sagemaker.serve.spec.inference_spec import InferenceSpec
from transformers import pipeline
class MyInferenceSpec(InferenceSpec):
def load(self, model_dir: str):
return pipeline("translation_en_to_fr", model="t5-small")
def invoke(self, input, model):
return model(input)
inf_spec = MyInferenceSpec()
model_builder = ModelBuilder(
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(X_test, y_pred)
)
```
次の例は、前述の例の、よりカスタマイズされたバリエーションを示しています。モデルは、依存関係を持つ推論仕様で定義されます。この場合、推論仕様のコードは、*lang-segment* パッケージによって異なります。`dependencies` の引数には、Git を使用して *lang-segment* をインストールするようにビルダーに指示するステートメントが含まれています。モデルビルダーはユーザーから依存関係をカスタムインストールするように指示されるため、`auto` キーは依存関係の自動キャプチャをオフにする `False` です。
```
model_builder = ModelBuilder(
mode=Mode.LOCAL_CONTAINER,
model_path=model-artifact-directory,
inference_spec=your-inference-spec,
schema_builder=SchemaBuilder(input, output),
role_arn=execution-role,
dependencies={"auto": False, "custom": ["-e git+https://github.com/luca-medeiros/lang-segment-anything.git#egg=lang-sam"],}
)
```
## モデルの構築とデプロイ
`build` 関数を呼び出して、デプロイ可能なモデルを作成します。このステップでは、スキーマの作成、入出力のシリアル化と逆シリアル化の実行、その他のユーザー指定のカスタムロジックの実行に必要なコードを含む推論コード (`inference.py` として) を、作業ディレクトリに作成します。
整合性チェックとして、SageMaker AI は `ModelBuilder` ビルド関数の一部としてデプロイに必要なファイルをパッケージ化して pickle 化します。このプロセス中、SageMaker AI は pickle ファイルの HMAC 署名も作成し、`deploy` (または `create`) 中に、シークレットキーを環境変数として [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) API に追加します。エンドポイントの起動では、環境変数を使用して、pickle ファイルの整合性を検証します。
```
# Build the model according to the model server specification and save it as files in the working directory
model = model_builder.build()
```
モデルの既存の `deploy` メソッドを使用して、モデルをデプロイします。このステップでは、SageMaker AI は、受信リクエストに応じて予測の作成を開始するときにモデルをホストするように、エンドポイントを設定します。`ModelBuilder` はモデルのデプロイに必要なエンドポイントリソースを推測しますが、これらの見積りは独自のパラメータ値で上書きできます。次の例では、1 つの `ml.c6i.xlarge` インスタンスにモデルをデプロイするように SageMaker AI に指示します。`ModelBuilder` で構築されたモデルでは、デプロイ中に追加機能としてライブログ記録が可能になります。
```
predictor = model.deploy(
initial_instance_count=1,
instance_type="ml.c6i.xlarge"
)
```
モデルに割り当てられたエンドポイントリソースをより細かく制御したい場合は、`ResourceRequirements` オブジェクトを使用できます。`ResourceRequirements` オブジェクトを使用すると、デプロイするモデルの CPU、アクセラレーター、コピーの最小数をリクエストできます。メモリの最小および最大バウンド (MB) をリクエストすることもできます。この機能を使用するには、エンドポイントタイプを `EndpointType.INFERENCE_COMPONENT_BASED` として指定する必要があります。次の例では、4 つのアクセラレーター、最小メモリサイズ 1,024 MB、モデルのコピー 1 つをタイプ `EndpointType.INFERENCE_COMPONENT_BASED` のエンドポイントにデプロイすることをリクエストします。
```
resource_requirements = ResourceRequirements(
requests={
"num_accelerators": 4,
"memory": 1024,
"copies": 1,
},
limits={},
)
predictor = model.deploy(
mode=Mode.SAGEMAKER_ENDPOINT,
endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED,
resources=resource_requirements,
role="role"
)
```
## 独自のコンテナ (BYOC)
独自のコンテナ (SageMaker AI コンテナから拡張) を持ち込む場合は、次の例に示すように、イメージ URI を指定することもできます。また、モデルサーバーに固有のアーティファクトを生成するには、`ModelBuilder` のイメージに対応するモデルサーバーを特定する必要があります。
```
model_builder = ModelBuilder(
model=model,
model_server=ModelServer.TORCHSERVE,
schema_builder=SchemaBuilder(X_test, y_pred),
image_uri="123123123123.dkr.ecr.ap-southeast-2.amazonaws.com/byoc-image:xgb-1.7-1")
)
```
## ローカルモードで ModelBuilder を使用する
`mode` 引数を使用してローカルテストとエンドポイントへのデプロイを切り替えることで、モデルをローカルにデプロイできます。次のスニペットに示すように、モデルアーティファクトを作業ディレクトリに保存する必要があります。
```
model = XGBClassifier()
model.fit(X_train, y_train)
model.save_model(model_dir + "/my_model.xgb")
```
モデルオブジェクトである `SchemaBuilder` インスタンスを渡し、モードを `Mode.LOCAL_CONTAINER` に設定します。`build` 関数を呼び出すと、`ModelBuilder` はサポートされているフレームワークコンテナを自動的に識別し、依存関係をスキャンします。次の例は、ローカルモードで XGBoost モデルを使用したモデルの作成を示しています。
```
model_builder_local = ModelBuilder(
model=model,
schema_builder=SchemaBuilder(X_test, y_pred),
role_arn=execution-role,
mode=Mode.LOCAL_CONTAINER
)
xgb_local_builder = model_builder_local.build()
```
次のスニペットに示すように、`deploy` 関数を呼び出してローカルにデプロイします。インスタンスタイプまたはカウントにパラメータを指定すると、これらの引数は無視されます。
```
predictor_local = xgb_local_builder.deploy()
```
### ローカルモードのトラブルシューティング
個々のローカル設定によっては、環境でスムーズに `ModelBuilder` を実行できない場合があります。直面する可能性のある問題とその解決方法については、次のリストを参照してください。
+ **既に使用されています**: `Address already in use` エラーが発生する可能性があります。この場合、Docker コンテナがそのポートで実行されているか、別のプロセスで使用されている可能性があります。[Linux ドキュメント](https://www.cyberciti.biz/faq/what-process-has-open-linux-port/)で説明されているアプローチに従ってプロセスを特定し、ローカルプロセスをポート 8080 から別のポートに適切にリダイレクトするか、Docker インスタンスをクリーンアップします。
+ **IAM アクセス許可の問題**: Amazon ECR イメージをプルしたり、Amazon S3 にアクセスしようとした際に、アクセス許可の問題が発生する可能性があります。この場合、ノートブックまたは Studio Classic インスタンスの実行ロールに移動して、`SageMakerFullAccess` のポリシー、またはそれぞれの API アクセス許可を検証します。
+ **EBS ボリューム容量の問題**: 大規模言語モデル (LLM) をデプロイする場合、ローカルモードで Docker を実行している間にスペースが不足したり、Docker キャッシュのスペース制限が発生したりする可能性があります。この場合、Docker ボリュームを、十分なスペースがあるファイルシステムに移動します。Docker ボリュームを移動するには、次の手順を実行します。
1. 次の出力に示すように、ターミナルを開き、`df` を実行してディスク使用量を表示します。
```
(python3) sh-4.2$ df
Filesystem 1K-blocks Used Available Use% Mounted on
devtmpfs 195928700 0 195928700 0% /dev
tmpfs 195939296 0 195939296 0% /dev/shm
tmpfs 195939296 1048 195938248 1% /run
tmpfs 195939296 0 195939296 0% /sys/fs/cgroup
/dev/nvme0n1p1 141545452 135242112 6303340 96% /
tmpfs 39187860 0 39187860 0% /run/user/0
/dev/nvme2n1 264055236 76594068 176644712 31% /home/ec2-user/SageMaker
tmpfs 39187860 0 39187860 0% /run/user/1002
tmpfs 39187860 0 39187860 0% /run/user/1001
tmpfs 39187860 0 39187860 0% /run/user/1000
```
1. 256 GB の SageMaker AI ボリュームを最大限に活用できるように、デフォルトの Docker ディレクトリを `/dev/nvme0n1p1` から `/dev/nvme2n1` に移動します。詳細については、[Docker ディレクトリを移動](https://www.guguweb.com/2019/02/07/how-to-move-docker-data-directory-to-another-location-on-ubuntu/)する方法に関するドキュメントを参照してください。
1. 次のコマンドを使用して Docker を停止します。
```
sudo service docker stop
```
1. `daemon.json` を `/etc/docker` に追加するか、次の JSON ブロブを既存のものに追加します。
```
{
"data-root": "/home/ec2-user/SageMaker/{created_docker_folder}"
}
```
1. 次のコマンドを使用して、`/var/lib/docker` の Docker ディレクトリを `/home/ec2-user/SageMaker AI` に移動します。
```
sudo rsync -aP /var/lib/docker/ /home/ec2-user/SageMaker/{created_docker_folder}
```
1. 次のコマンドを使用して Docker を開始します。
```
sudo service docker start
```
1. 次のコマンドを使用してごみ箱をクリーンアップします。
```
cd /home/ec2-user/SageMaker/.Trash-1000/files/*
sudo rm -r *
```
1. SageMaker ノートブックインスタンスを使用している場合は、[Docker 準備ファイル](https://github.com/melanie531/amazon-sagemaker-pytorch-lightning-distributed-training/blob/main/prepare-docker.sh)の手順に従って、Docker をローカルモード用に準備できます。
## ModelBuilder の例
`ModelBuilder` を使用してモデルを構築するその他の例については、「[ModelBuilder sample notebooks](https://github.com/aws-samples/sagemaker-hosting/blob/main/SageMaker-Model-Builder)」を参照してください。
# Amazon SageMaker AI モデルに対する推論の最適化
Amazon SageMaker AI を使用すると、推論の最適化手法を適用して生成 AI モデルのパフォーマンスを向上できます。モデルを最適化することで、ユースケースのコストパフォーマンスを向上できます。モデルを最適化する場合、量子化、投機的デコーディング、コンパイルなど、サポートされている最適化手法のいずれかを選択して適用します。モデルを最適化したら、評価を実行して、レイテンシー、スループット、料金のパフォーマンスメトリクスを確認できます。
また、SageMaker AI では、多くのモデルについて、事前に最適化されたバージョンをいくつか提供しており、それぞれがレイテンシーとスループットに対するさまざまなアプリケーションのニーズに対応しています。このようなモデルを使用すれば、最初にモデルを自分で最適化することなく、最適化されたバージョンのいずれかをデプロイできます。
## 最適化手法
Amazon SageMaker AI は、以下の最適化手法に対応しています。
### コンパイル
*コンパイル*により、精度を損なわずに、選択したハードウェアタイプで利用可能な最高のパフォーマンスを実現するためにモデルが最適化されます。モデルコンパイルを適用すると、GPU インスタンス、AWS Trainium インスタンス、AWS Inferentia インスタンスなどの高速ハードウェアに対して LLM を最適化できます。
コンパイルを使用してモデルを最適化する場合、事前にコンパイルできるというメリットがあります。これにより、モデルのデプロイ時間と自動スケーリングレイテンシーを短縮できます。モデルが新しいインスタンスにデプロイされるときに、モデルの重みに JIT コンパイルが不要になるためです。
GPU インスタンスのモデルをコンパイルすることにした場合、SageMaker AI では TensorRT-LLM ライブラリを使用してコンパイルを実行します。AWS Trainium インスタンスか AWS Inferentia インスタンスのモデルをコンパイルすることにした場合、SageMaker AI では AWS Neuron SDK を使用してコンパイルを実行します。
### 量子化
*量子化*は、重みとアクティベーションに精度の低いデータ型を使用することで、モデルのハードウェア要件を下げる手法です。量子化でモデルを最適化すると、より安価でより利用しやすい GPU でホストできます。ただし、量子化されたモデルは、最適化したソースモデルよりも精度が低い場合があります。
量子化のために SageMaker AI でサポートされているデータ形式はモデルによって異なります。サポートされている形式には以下が含まれています。
+ INT4-AWQ – 4 ビットデータ形式。Activation-aware Weight Quantization (AWQ) は、効率的で、正確、低ビット、重み専用の LLM のための量子化手法です。
+ FP8 – 8 ビット浮動小数点 (FP8) は、浮動小数点数の低精度形式です。この形式では、標準の FP16 浮動小数点形式よりもビット数が少ない値を表すことで、メモリ効率とモデル精度のバランスを取っています。
+ INT8-SmoothQuant – 8 ビットデータ形式。SmoothQuant は、動的範囲のバランスを取ることで、アクティベーションと重みの両方をスケールする混合精度量子化方法です。
### 投機デコーディング
*投機的デコーディング*とは、大規模な LLM のデータコーディング処理の速度を向上させる技術です。生成されたテキストの品質を損なうことなく、レイテンシーに対してモデルを最適化します。
この手法では、*ドラフト*モデルと呼ばれる、より高速で処理できる小さなモデルを使用します。ドラフトモデルは候補トークンを生成し、サイズが大きく処理に時間がかかる*ターゲット*モデルによって検証されます。反復ごとに、ドラフトモデルは複数の候補トークンを生成します。ターゲットモデルはトークンを検証し、特定のトークンが受け入れられないことが判明した場合、トークンを拒否して再生成します。このように、ターゲットモデルは、トークンの検証と少量のトークンの生成を行います。
ドラフトモデルはターゲットモデルよりも処理がはるかに高速です。すべてのトークンを迅速に生成し、検証のためにそれらのバッチをターゲットモデルに送信します。ターゲットモデルはこれらすべてを並列で評価するため、最終的なレスポンスが高速化されます。
SageMaker AI には、構築済みのドラフトモデルが使用できる状態で用意されており、独自のドラフトモデルを構築する必要はありません。SageMaker AI は独自のカスタムドラフトモデルの使用にも対応しているため、必要に応じてモデルを選択できます。
### 高速モデルロード
*高速モデルロード*手法では、SageMaker AI が ML インスタンスによりすばやくロードできるように LLM を準備します。
モデルを準備するために、SageMaker AI は、分散推論のためにそれぞれが別々の GPU に存在することができる部分に分割することで、事前にモデルをシャードします。また、SageMaker AI は、SageMaker AI がインスタンスに同時にロードできる同じサイズのチャンクにモデルの重みを保存します。
SageMaker AI が最適化されたモデルをインスタンスにロードすると、モデルの重みが Amazon S3 から直接インスタンスの GPU にストリーミングされます。重みをストリーミングすることで、SageMaker AI は通常必要ないくつかの時間のかかるステップを省略します。これらのステップには、Amazon S3 からディスクへのモデルアーティファクトのダウンロード、ホストメモリへのモデルアーティファクトのロード、最後にシャードを GPU にロードする前のホストへのモデルのシャードが含まれます。
ロードを高速化するためにモデルを最適化したら、SageMaker AI エンドポイントにより迅速にモデルをデプロイできます。また、自動スケーリングを使用するようにエンドポイントを設定すると、トラフィックの増加に対応するためにより迅速にスケールアウトされます。
# 事前に最適化されたモデルのデプロイ
JumpStart の一部のモデルは SageMaker AI によって事前に最適化されています。つまり、最初に推論最適化ジョブを作成することなく、これらのモデルの最適化されたバージョンをデプロイできます。
事前に最適化されたオプションが用意されているモデルのリストについては、「[事前に最適化された JumpStart モデル](#pre-optimized-js)」を参照してください。
## Amazon SageMaker Studio
Amazon SageMaker Studio を使用して事前に最適化された JumpStart モデルをデプロイするには、次の手順に従います。
**事前に最適化されたモデルをデプロイするには**
1. Studio の左側のナビゲーションメニューで、**[JumpStart]** を選択します。
1. **[すべてのパブリックモデル]** ページで、事前に最適化されているモデルのいずれかを選択します。
1. モデルの詳細ページで、**[デプロイ]** を選択します。
1. 一部の JumpStart モデルでは、デプロイページで、続行する前にエンドユーザーライセンス契約 (EULA) に署名する必要があります。要求された場合、**[ライセンス契約]** セクションのライセンス条項を確認してください。その条項がユースケースで受け入れられる場合は、**[EULA に同意し、利用規約を読みました]** のチェックボックスをオンにします。
詳細については、「[エンドユーザーライセンス契約](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula)」を参照してください。
1. **[エンドポイント名]** と **[初期インスタンス数]** は、デフォルト値を受け入れるか、カスタム値を設定します。
1. **[インスタンスタイプ]** は、デフォルト値のままにします。それ以外の場合、事前に最適化された設定をデプロイできません。
1. **[モデル]** で、モデル設定を展開します。Studio の表に、事前い最適化され、選択可能な設定が表示されます。各オプションには、レイテンシーとスループットのメトリクスがあります。アプリケーションのニーズに最適なオプションを選択します。
1. **[デプロイ]** を選択します。
## SageMaker AI Python SDK
プロジェクトで SageMaker AI Python SDK を使用して、事前最適化済みモデルをデプロイできます。まず、`ModelBuilder` クラスを使用して `Model` インスタンスを定義します。次に、`set_deployment_config()` メソッドを使用して、デプロイする事前最適化済み構成を設定します。その後、`build()` メソッドを使用してモデルを構築します。最後に、`deploy()` メソッドを使用してそれを推論エンドポイントにデプロイします。
次の例で使用されているクラスとメソッドの詳細については、SageMaker AI Python SDK ドキュメントの「[APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)」を参照してください。
**プロジェクトをセットアップするには**
1. アプリケーションコードで、必要なライブラリをインポートします。以下の例では、SDK for Python (Boto3) をインポートします。また、モデルの定義と操作に使用するモジュールを SageMaker AI Python SDK からインポートします。
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
```
1. SageMaker AI セッションを初期化します。次の例では `Session()` クラスを使用しています。
```
sagemaker_session = Session()
```
**モデルを定義するには**
1. `SchemaBuilder` インスタンスを作成し、入力サンプルと出力サンプルを提供します。モデルを定義するときに、このインスタンスを `ModelBuilder` クラスに指定します。これにより、SageMaker AI は入力と出力をシリアル化および逆シリアル化するためのマーシャリング関数を自動的に生成します。
`SchemaBuilder` または `ModelBuilder` クラスの使用の詳細については、「[ModelBuilder を使用して Amazon SageMaker AI でモデルを作成する](how-it-works-modelbuilder-creation.md)」を参照してください。
次の例では、`SchemaBuilder` クラスに入力文字列の例と出力文字列の例を提供します。
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. モデルを SageMaker AI に定義します。次の例では、`ModelBuilder` インスタンスを初期化するようにパラメータを設定します。
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
この例では、JumpStart モデルを使用しています。`jumpstart-model-id` を `meta-textgeneration-llama-3-70b` などの JumpStart モデルの ID に置き換えます。
**ベンチマークメトリクスを取得するには**
1. デプロイ対象の事前に最適化された設定を確認するには、SageMaker AI が提供するオプションを調べます。次の例をご覧ください。
```
model_builder.display_benchmark_metrics()
```
この `display_benchmark_metrics()` メソッドにより、次のようなテーブルが出力されます。
```
| Instance Type | Config Name | Concurrent Users | Latency, TTFT (P50 in sec) | Throughput (P50 in tokens/sec/user) |
|:----------------|:--------------|-------------------:|-----------------------------:|--------------------------------------:|
| ml.g5.48xlarge | lmi-optimized | 1 | 2.25 | 49.70 |
| ml.g5.48xlarge | lmi-optimized | 2 | 2.28 | 21.10 |
| ml.g5.48xlarge | lmi-optimized | 4 | 2.37 | 14.10 |
. . .
| ml.p4d.24xlarge | lmi-optimized | 1 | 0.10 | 137.40 |
| ml.p4d.24xlarge | lmi-optimized | 2 | 0.11 | 109.20 |
| ml.p4d.24xlarge | lmi-optimized | 4 | 0.13 | 85.00 |
. . .
```
テーブルの最初の列には、選択した JumpStart モデルのホストに使用できる潜在的なインスタンスタイプが一覧表示されています。インスタンスタイプごとに、`Config Name` の下に、事前に最適化された設定の名前が一覧表示されます。SageMaker AI が提供する設定の名前は `lmi-optimized` です。インスタンスタイプと設定ごとに、テーブルにベンチマークメトリクスが表示されます。これらのメトリクスは、モデルがさまざまな数の同時ユーザーに対して対応するスループットとレイテンシーを示します。
1. ベンチマークメトリクスに基づいて、パフォーマンスニーズに最適なインスタンスタイプと設定名を選択します。これらの値は、デプロイ設定を作成するときに使用します。
**事前に最適化されたモデルをデプロイするには**
1. デプロイ設定を作成します。次の例では、`ModelBuilder` インスタンスを使用します。インスタンスタイプと設定名が `set_deployment_config()` メソッドに渡されます。
```
model_builder.set_deployment_config(
config_name="config-name",
instance_type="instance-type",
)
```
`lmi-optimized` などのテーブルの設定名 を *`config-name`* に置き換えます。`ml.p4d.24xlarge` などのテーブルのインスタンスタイプを `instance-type` に置き換えます。
1. モデルをビルドします。次の例では、`ModelBuilder` インスタンスの `.build()` メソッドを使用します。
```
optimized_model = model_builder.build()
```
`.build()` メソッドはデプロイ可能な `Model` インスタンスを返します。
1. モデルを推論エンドポイントにデプロイします。次の例では、`Model` インスタンスの `.deploy()` メソッドを使用します。
```
predictor = optimized_model.deploy(accept_eula=True)
```
`deploy()` メソッドは `Predictor` インスタンスを返します。このインスタンスを使用すると、モデルに推論リクエストを送信できます。
**推論リクエストを使用してモデルをテストするには**
+ モデルを推論エンドポイントにデプロイしたら、モデル予測をテストします。次の例では、`Predictor` インスタンスを使用して推論リクエストを送信します。
```
predictor.predict(sample_input)
```
モデルは、次のようなレスポンスで生成されるテキストを返します。
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## 事前に最適化された JumpStart モデル
設定が事前に最適化されている JumpStart モデルを次に示します。
**Meta**
+ Llama 3.1 70B Instruct
+ Llama 3.1 70B
+ Llama 3.1 405B Instruct FP8
+ Llama 3.1 405B FP8
+ Llama 3 8B Instruct
+ Llama 3 8B
+ Llama 3 70B Instruct
+ Llama 3 70B
+ Llama 2 70B Chat
+ Llama 2 7B Chat
+ Llama 2 13B Chat
**HuggingFace**
+ Mixtral 8x7B Instruct
+ Mixtral 8x7B
+ Mistral 7B Instruct
+ Mistral 7B
### 事前にコンパイルされた JumpStart モデル
一部のモデルと設定について、SageMaker AI では、特定の AWS Inferentia インスタンスと AWS Trainium インスタンス用に事前にコンパイルされたモデルを利用できます。これらのモデルについて、コンパイル最適化ジョブを作成し、デプロイインスタンスタイプとして ml.inf2.48xlarge または ml.trn1.32xlarge を選択した場合、SageMaker AI はコンパイルされたアーティファクトを取得します。ジョブは、既にコンパイルされているモデルを使用するため、コンパイルを初めから実行する必要がなく、迅速に完了します。
以下は、SageMaker AI によってモデルが事前にコンパイルされた JumpStart モデルです。
**Meta**
+ Llama3 8B
+ Llama3 70B
+ Llama2 7B
+ Llama2 70B
+ Llama2 13B
+ Code Llama 7B
+ Code Llama 70B
**HuggingFace**
+ Mistral 7B
# 推論最適化ジョブを作成する
Studio または SageMaker AI Python SDK を使用して、推論最適化ジョブを作成できます。ジョブでは、選択した手法を適用してモデルを最適化します。詳細については、「[最適化手法](model-optimize.md#optimization-techniques)」を参照してください。
**推論最適化ジョブのインスタンス料金**
量子化またはコンパイルを適用する推論最適化ジョブを作成すると、SageMaker AI は、ジョブを実行するのに使用するインスタンスタイプを選択します。料金は、使用されたインスタンスに基づいて請求されます。
可能なインスタンスタイプとその料金の詳細については、「[Amazon SageMaker の料金](https://aws.amazon.com/sagemaker/pricing/)」ページの推論の最適化の料金情報を参照してください。
投機的デコードを適用するジョブについては、追加コストは発生しません。
最適化できるサポート対象モデルについては、「[サポートされているモデルリファレンス](optimization-supported-models.md)」を参照してください。
## Amazon SageMaker Studio
Studio で推論最適化ジョブを作成するには、次の手順を実行します。
**最適化ジョブの作成を開始するには**
1. SageMaker AI Studio で、次のいずれかのパスを使用して最適化ジョブを作成します。
+ JumpStart モデルのジョブを作成するには、次の手順を実行します。
1. ナビゲーションメニューで、**[JumpStart]** を選択します。
1. **[すべてのパブリックモデル]** ページで、モデルプロバイダーを選択して、最適化に対応するモデルのいずれかを選択します。
1. モデルの詳細ページで、**[最適化]** を選択します。このボタンは、最適化に対応するモデルでのみ有効です。
1. 一部の JumpStart モデルでは、**[推論最適化ジョブの作成]** ページで、続行する前にエンドユーザーライセンス契約 (EULA) に署名する必要があります。要求された場合、**[ライセンス契約]** セクションのライセンス条項を確認してください。その条項がユースケースで受け入れられる場合は、**[EULA に同意し、利用規約を読みました]** のチェックボックスをオンにします。
+ ファインチューニングされた JumpStart モデルのジョブを作成するには、以下を実行します。
1. ナビゲーションペインの **[ジョブ]** で、**[トレーニング]** を選択します。
1. **[トレーニングジョブ]** ページで、JumpStart モデルのファインチューニングに使用したジョブの名前を選択します。これらのジョブのタイプは、**[ジョブタイプ]** 列で **[JumpStart トレーニング]** が指定されています。
1. トレーニングジョブの詳細ページで、**[最適化]** を選択します。
+ カスタムモデルのジョブを作成するには、次の手順を実行します。
1. ナビゲーションメニューの **[ジョブ]** で、**[推論最適化]** を選択します。
1. [**Create new job (新しいジョブを作成)**] を選択します。
1. **[推論最適化ジョブの作成]** ページで、**[モデルを追加]** を選択します。
1. **[モデルを追加]** ウィンドウで、**[カスタムモデル]** を選択します。
1. 以下のオプションのいずれかを選択してください。
**既存のモデルを使用する** - SageMaker AI で既に作成したモデルを最適化するには、このオプションを選択します。
**既存のモデル名** - SageMaker AI モデルの名前を入力します。
**S3 から** - Amazon S3 からモデルアーティファクトを提供するには、このオプションを選択します。**[S3 URI]** には、モデルアーティファクトを保存した Amazon S3 の場所の URI を入力します。
1. (オプション) ****出力モデル名****には、ジョブが作成する最適化されたモデルのカスタム名を入力できます。名前を指定しない場合、Studio は選択内容に基づいて名前を自動的に生成します。
1. **[推論最適化ジョブの作成]** ページの **[ジョブ名]** では、SageMaker AI によって割り当てられたデフォルト名を受け入れてもかまいません。カスタムジョブ名を入力する場合は、**[ジョブ名]** フィールドを選択して、**[ジョブ名を入力]** を選択します。
**最適化設定を設定するには**
1. **[デプロイインスタンスタイプ]** で、モデルを最適化するインスタンスタイプを選択します。
インスタンスタイプにより、選択できる最適化手法は影響を受けます。GPU ハードウェアを使用するほとんどのタイプでは、サポートされている手法は**量子化**と**投機的デコード**です。Inferentia インスタンス ml.inf2.8xlarge AWS など、カスタムシリコンを使用するインスタンスを選択した場合、サポートされている手法は**コンパイル**です。これは、その特定のハードウェアタイプのモデルをコンパイルするために使用できます。
1. Studio が提供する最適化手法を 1 つ以上選択します。
+ **[量子化]** では、**[Precision データ型]**を選択します。
+ **[投機デコーディング]** を選択する場合は、以下のオプションの 1 つを選択します。
+ **SageMaker AI ドラフトモデルを使用する** – SageMaker AI に用意されているドラフトモデルを使用する場合に選択します。
**注記**
SageMaker AI ドラフトモデルを使用することにした場合は、ネットワーク分離も有効にする必要があります。Studio では、このオプションが **[セキュリティ]** の下にあります。
+ **JumpStart ドラフトモデルを選択** – ドラフトモデルとして使用する JumpStart カタログからモデルを選択する場合に選択します。
+ **独自のドラフトモデルを選択** - 独自のドラフトモデルを使用し、その場所の S3 URI を指定する場合に選択します。
+ **[高速モデルロード]** を選択すると、Studio に `OPTION_TENSOR_PARALLEL_DEGREE` 環境変数が表示されます。**[値]** フィールドを使用して、テンソル並列処理の度合いを設定します。値は、**[デプロイインスタンスタイプ]** に対して選択したインスタンス内の GPU の数を均等に分割する必要があります。例えば、GPU 数が 8 のインスタンスを使用している場合にモデルをシャーディング (分割) するには、値 2、4、または 8 を使用します。
+ **デプロイインスタンスタイプ**を AWS Inferentia または AWS Trainium インスタンスに設定すると、Studio は**サポートされている**オプションの 1 つであることを示す場合があります。この場合、Studio ではこのオプションを選択します。
1. **[出力]** で、Amazon S3 の場所の URI を入力します。ここで、SageMaker AI は、ジョブで作成された最適化モデルのアーティファクトを保存します。
1. (オプション) IAM ロール、VPC、環境変数などの設定をよりきめ細かく制御するには、**[詳細オプション]** を展開します。詳細については、以下の「*詳細オプション*」を参照してください。
1. ジョブの設定が完了したら、**[ジョブの作成]** を選択します。
Studio にジョブの詳細ページが表示され、ジョブのステータスとそのすべての設定を確認できます。
### 高度なオプション
推論最適化ジョブを作成する際、次の詳細オプションを設定できます。
**[設定]**では、次のオプションを設定できます。
**テンソル並列度 **
*テンソル並列*度の値。テンソル並列処理は、特定のモデルの重み、勾配、オプティマイザ状態がデバイス間で分割されるモデル並列処理の一種です。クラスター内の GPU の数を割り切れる値にする必要があります。
**トークンの最大長**
モデルによって生成されるトークンの数の制限。モデルが常にトークンの最大数を生成するとは限りません。
**同時実行**
同じ基盤となるハードウェアでモデルの複数のインスタンスを実行する機能。同時実行を使用すると、複数のユーザーに予測を提供し、ハードウェア使用率を最大化できます。
**バッチサイズ**
モデルで*バッチ推論*が実行される場合は、このオプションを使用して、モデルが処理するバッチのサイズを制御します。
バッチ推論は、バッチ観測に基づいてモデル予測を生成します。このオプションは、データセットが大きい場合や、推論のリクエストにすぐに応答する必要がない場合に適しています。
**[セキュリティ]** では、次のオプションを設定できます。
**IAM ロール**
SageMaker AI がユーザーに代わってタスクを実行できるようにする IAM ロール。モデルの最適化中、SageMaker AI には以下のアクセス許可が必要です。
+ S3 バケットからの入力データの読み取り
+ S3 バケットへのモデルアーティファクトを書き込み
+ Amazon CloudWatch Logs へのログの書き込み
+ Amazon CloudWatch へのメトリクスの公開
これらのすべてのタスクに対するアクセス許可を IAM ロールに付与します。
詳細については、「[SageMaker AI 実行ロールの使用方法](sagemaker-roles.md)」を参照してください。
**暗号化 KMS キー**
AWS Key Management Service () のキーAWS KMS。SageMaker AI は、SageMaker AI がモデルを Amazon S3 にアップロードするときに、これらのキーを使用して、最適化されたモデルのアーティファクトを暗号化します。
**VPC**
SageMaker AI は、この情報を使用してネットワークインターフェイスを作成し、モデルコンテナにアタッチします。ネットワークインターフェイスは、インターネットに接続されていない VPC 内のネットワーク接続をモデルコンテナに提供します。また、モデルがプライベート VPC 内のリソースに接続できるようにします。
詳細については、「[Amazon VPC のリソースへのアクセス権を SageMaker AI のホストされたエンドポイントに付与する](host-vpc.md)」を参照してください。
**ネットワーク分離の有効化**
コンテナのインターネットアクセスを制限する場合は、このオプションを有効にします。ネットワーク分離で実行されるコンテナは、アウトバウンドネットワークコールを実行できません。
このオプションは、投機的デコードで最適化し、SageMaker AI ドラフトモデルを使用するときにアクティブ化する必要があります。
ネットワーク分離の詳細については、「[ネットワークの隔離](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation)」を参照してください。
**[詳細なコンテナ定義]** では、次のオプションを設定できます。
**停止条件**
ジョブの実行時間の制限を指定します。ジョブが制限時間に達すると、SageMaker AI はジョブを終了します。このオプションを使用してコストを制限します。
**タグ**
最適化ジョブに関連付けられたキーと値のペア。
タグの詳細については、「*AWS 全般のリファレンス*」の「[Tagging your AWS resources](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html)」を参照してください。
**環境変数**
モデルコンテナに設定する環境変数を定義するキーと値のペア。
## SageMaker AI Python SDK
プロジェクトで SageMaker AI Python SDK を使用して、推論最適化ジョブを作成できます。まず、`ModelBuilder` クラスを使用して `Model` インスタンスを定義します。次に、`optimize()` メソッドを使用して、量子化、投機的デコード、またはコンパイルでモデルを最適化するジョブを実行します。ジョブが完了したら、`deploy()` メソッドを使用してモデルを推論エンドポイントにデプロイします。
次の例で使用されているクラスとメソッドの詳細については、SageMaker AI Python SDK ドキュメントの「[APIs](https://sagemaker.readthedocs.io/en/stable/api/index.html)」を参照してください。
**プロジェクトをセットアップするには**
1. アプリケーションコードで、必要なライブラリをインポートします。以下の例では、SDK for Python (Boto3) をインポートします。また、モデルの定義と操作に使用するクラスを SageMaker AI Python SDK からインポートします。
```
import boto3
from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.session import Session
from pathlib import Path
```
1. SageMaker AI セッションを初期化します。次の例では `Session()` クラスを使用しています。
```
sagemaker_session = Session()
```
**モデルを定義するには**
1. `SchemaBuilder` インスタンスを作成し、入力サンプルと出力サンプルを提供します。モデルを定義するときに、このインスタンスを `ModelBuilder` クラスに指定します。これにより、SageMaker AI は入力と出力をシリアル化および逆シリアル化するためのマーシャリング関数を自動的に生成します。
`SchemaBuilder` または `ModelBuilder` クラスの使用の詳細については、「[ModelBuilder を使用して Amazon SageMaker AI でモデルを作成する](how-it-works-modelbuilder-creation.md)」を参照してください。
次の例では、`SchemaBuilder` クラスに入力文字列の例と出力文字列の例を提供します。
```
response = "Jupiter is the largest planet in the solar system. It is the fifth planet from the sun."
sample_input = {
"inputs": "What is the largest planet in the solar system?",
"parameters": {"max_new_tokens": 128, "top_p": 0.9, "temperature": 0.6},
}
sample_output = [{"generated_text": response}]
schema_builder = SchemaBuilder(sample_input, sample_output)
```
1. モデルを SageMaker AI に定義します。次の例では、`ModelBuilder` インスタンスを初期化するようにパラメータを設定します。
```
model_builder = ModelBuilder(
model="jumpstart-model-id",
schema_builder=schema_builder,
sagemaker_session=sagemaker_session,
role_arn=sagemaker_session.get_caller_identity_arn(),
)
```
この例では、JumpStart モデルを使用しています。`jumpstart-model-id` を `meta-textgeneration-llama-3-70b` などの JumpStart モデルの ID に置き換えます。
**注記**
投機的デコードで最適化し、SageMaker AI ドラフトを使用する場合は、ネットワーク分離を有効にする必要があります。これを有効にするには、`ModelBuilder` インスタンスを初期化するときに次の引数を含めます。
```
enable_network_isolation=True,
```
ネットワーク分離の詳細については、「[ネットワークの隔離](mkt-algo-model-internet-free.md#mkt-algo-model-internet-free-isolation)」を参照してください。
**量子化で最適化するには**
1. 量子化ジョブを実行するには、`optimize()` メソッドを使用して `quantization_config` 引数を設定します。次の例では、最適化コンテナの環境変数として `OPTION_QUANTIZE` を設定しています。
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
quantization_config={
"OverrideEnvironment": {
"OPTION_QUANTIZE": "awq",
},
},
output_path="s3://output-path",
)
```
この例では、*`instance-type`* を `ml.p4d.24xlarge` などの ML インスタンスに置き換えます。*`s3://output-path`* を、ジョブが作成する最適化されたモデルを保存する S3 の場所へのパスに置き換えます。
`optimize()` メソッドは、モデルをエンドポイントにデプロイするために使用できる `Model` オブジェクトを返します。
1. ジョブが完了したら、モデルをデプロイします。次の例では、`deploy()` メソッドを使用しています。
```
predictor = optimized_model.deploy(
instance_type="instance-type",
accept_eula=True,
)
```
この例では、*`instance-type`* を `ml.p4d.24xlarge` などの ML インスタンスに置き換えます。
`deploy()` メソッドは、モデルをホストするエンドポイントに推論リクエストを送信するために使用できる予測子オブジェクトを返します。
**SageMaker AI ドラフトモデルを使用して投機的デコードで最適化するには**
投機的デコードでモデルを最適化する際は、SageMaker AI に用意されているドラフトモデルを使用するか、独自のモデルを使用するかを選択できます。次の例では、SageMaker AI ドラフトモデルを使用しています。
**前提条件**
投機的デコードと SageMaker AI ドラフトモデルで最適化するには、モデルを定義する際にネットワーク分離を有効にする必要があります。
1. 投機的デコードジョブを実行するには、`optimize()` メソッドを使用し、`speculative_decoding_config` 引数を設定します。次の例では、SageMaker AI に用意されているドラフトモデルを使用するように `ModelProvider` キーを `SAGEMAKER` に設定しています。
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelProvider": "SAGEMAKER",
},
)
```
この例では、*`instance-type`* を `ml.p4d.24xlarge` などの ML インスタンスに置き換えます。
`optimize()` メソッドは、モデルをエンドポイントにデプロイするために使用できる `Model` オブジェクトを返します。
1. ジョブが完了したら、モデルをデプロイします。次の例では、`deploy()` メソッドを使用しています。
```
predictor = optimized_model.deploy(accept_eula=True)
```
`deploy()` メソッドは、モデルをホストするエンドポイントに推論リクエストを送信するために使用できる予測子オブジェクトを返します。
**カスタムドラフトモデルを使用して投機的デコードで最適化するには**
カスタムドラフトモデルを SageMaker AI に提供する前に、まずモデルアーティファクトを Amazon S3 にアップロードする必要があります。
次の例は、カスタムドラフトモデルを提供する 1 つの方法を示しています。この例では、Hugging Face Hub からドラフトモデルをダウンロードし、それを Amazon S3 にアップロードして、`speculative_decoding_config` 引数に S3 URI を提供しています。
1. Hugging Face Hub からモデルをダウンロードする場合は、`huggingface_hub` ライブラリをプロジェクトに追加し、`snapshot_download()` メソッドを使用してモデルをダウンロードします。次の例では、モデルをローカルディレクトリにダウンロードしています。
```
import huggingface_hub
huggingface_hub.snapshot_download(
repo_id="model-id",
revision="main",
local_dir=download-dir,
token=hf-access-token,
)
```
この例では、*`model-id`* を Hugging Face Hub のモデルの ID（例：`meta-llama/Meta-Llama-3-8B`）に置き換えます。*`download-dir`* をローカルディレクトリに置き換えます。*`hf-access-token`* をユーザーアクセストークンに置き換えます。アクセストークンを取得する方法については、Hugging Face ドキュメントの「[User access tokens](https://huggingface.co/docs/hub/en/security-tokens)」を参照してください。
`huggingface_hub` ライブラリの詳細については、Hugging Face ドキュメントの「[Hub client library](https://huggingface.co/docs/huggingface_hub/en/index)」を参照してください。
1. ダウンロードしたモデルを SageMaker AI で使用できるようにするには、Amazon S3 にアップロードします。次の例では、`sagemaker_session` オブジェクトを使用してモデルをアップロードしています。
```
custom_draft_model_uri = sagemaker_session.upload_data(
path=hf_local_download_dir.as_posix(),
bucket=sagemaker_session.default_bucket(),
key_prefix="prefix",
)
```
この例では、*`prefix`* を S3 のドラフトモデルを区別するのに役立つ修飾子（例: `spec-dec-custom-draft-model`）に置き換えます。
`upload_data()` メソッドは、モデルアーティファクトの S3 URI を返します。
1. 投機的デコードジョブを実行するには、`optimize()` メソッドを使用し、`speculative_decoding_config` 引数を設定します。次の例では、`ModelSource` キーをカスタムドラフトモデルの S3 URI に設定しています。
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
speculative_decoding_config={
"ModelSource": custom_draft_model_uri + "/",
},
)
```
この例では、*`instance-type`* を `ml.p4d.24xlarge` などの ML インスタンスに置き換えます。
`optimize()` メソッドは、モデルをエンドポイントにデプロイするために使用できる `Model` オブジェクトを返します。
1. ジョブが完了したら、モデルをデプロイします。次の例では、`deploy()` メソッドを使用しています。
```
predictor = optimized_model.deploy(accept_eula=True)
```
`deploy()` メソッドは、モデルをホストするエンドポイントに推論リクエストを送信するために使用できる予測子オブジェクトを返します。
**コンパイルで最適化するには**
1. コンパイルジョブを実行するには、`optimize()` メソッドを使用して `compilation_config` 引数を設定します。次の例では、`OverrideEnvironment` キーを使用して、最適化コンテナに必要な環境変数を設定しています。
```
optimized_model = model_builder.optimize(
instance_type="instance-type",
accept_eula=True,
compilation_config={
"OverrideEnvironment": {
"OPTION_TENSOR_PARALLEL_DEGREE": "24",
"OPTION_N_POSITIONS": "8192",
"OPTION_DTYPE": "fp16",
"OPTION_ROLLING_BATCH": "auto",
"OPTION_MAX_ROLLING_BATCH_SIZE": "4",
"OPTION_NEURON_OPTIMIZE_LEVEL": "2",
}
},
output_path="s3://output-path",
)
```
この例では、*`instance-type`* を高速ハードウェアを使用した ML インスタンスタイプに設定しています。たとえば、 AWS Inferentia による高速推論の場合、 タイプを などの Inf2 インスタンスに設定できます`ml.inf2.48xlarge`。*`s3://output-path`* を、ジョブが作成する最適化されたモデルを保存する S3 の場所へのパスに置き換えます。
1. ジョブが完了したら、モデルをデプロイします。次の例では、`deploy()` メソッドを使用しています。
```
predictor = optimized_model.deploy(accept_eula=True)
```
`deploy()` メソッドは、モデルをホストするエンドポイントに推論リクエストを送信するために使用できる予測子オブジェクトを返します。
**推論リクエストを使用してモデルをテストするには**
+ デプロイされたモデルにテスト推論リクエストを送信するには、予測子オブジェクトの `predict()` メソッドを使用します。次の例では、モデルを定義するために、例の `SchemaBuilder` クラスにも渡された `sample_input` 変数を渡しています。
```
predictor.predict(sample_input)
```
サンプル入力にはプロンプト `"What is the largest planet in the solar system?"` があります。次の例に示すように、`predict()` メソッドはモデルが生成したレスポンスを返します。
```
{'generated_text': ' Jupiter is the largest planet in the solar system. It is the fifth planet from the sun. It is a gas giant with . . .'}
```
## AWS SDK for Python (Boto3)
AWS SDK for Python (Boto3) を使用して、推論最適化ジョブをプログラムで作成および管理できます。このセクションでは、さまざまな最適化手法の例を示します。
**前提条件**
Boto3 で最適化ジョブを作成する前に、以下を確認してください。
+ 設定された AWS 認証情報 - 適切なアクセス許可で AWS 認証情報をセットアップする
+ SageMaker AI モデルを作成した (既存のモデルを使用している場合)
+ S3 で準備されたトレーニングデータ (投機的デコード最適化用、最大 4096 のコンテキスト長をサポート)
+ 必要なアクセス許可を持つ IAM ロール - 実行ロールには、S3 にアクセスして SageMaker リソースを作成するアクセス許可が必要です
**例: EAGLE 投機的デコードを使用した最適化ジョブの作成 (Llama 3.3 70B)**
この例では、EAGLE 投機的デコード手法を使用して大規模言語モデルの最適化ジョブを作成する方法を示します。
```
import boto3
# Initialize SageMaker client
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Step 1: Create a SageMaker model (if not already created)
model_response = sagemaker_client.create_model(
ModelName='meta-llama-3-3-70b-instruct',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/Llama-3.3-70B-Instruct/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'SAGEMAKER_ENV': '1',
'SAGEMAKER_MODEL_SERVER_TIMEOUT': '3600'
}
}
)
# Step 2: Create optimization job with speculative decoding
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'meta-llama-3-3-70b-instruct'
}
},
DeploymentInstanceType='ml.p4d.24xlarge',
# MaxInstanceCount specifies the maximum number of instances for distributed training
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_8k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/llama-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**例: S3 モデルアーティファクトから最適化ジョブを作成する (Qwen3 32B)**
この例では、S3 から直接モデルアーティファクトを使用して最適化ジョブを作成する方法を示します。
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Create model from S3 artifacts
model_response = sagemaker_client.create_model(
ModelName='qwen3-32b',
ExecutionRoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
PrimaryContainer={
'Image': '763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:',
'Mode': 'SingleModel',
'ModelDataSource': {
'S3DataSource': {
'S3Uri': 's3://my-bucket/models/qwen3-32b/',
'S3DataType': 'S3Prefix',
'CompressionType': 'None'
}
},
'Environment': {
'AWS_REGION': 'us-west-2'
}
}
)
# Create optimization job with smaller training dataset
optimization_response = sagemaker_client.create_optimization_job(
OptimizationJobName='qwen3-optim-job-eagle',
RoleArn='arn:aws:iam::123456789012:role/SageMakerExecutionRole',
ModelSource={
'SageMakerModel': {
'ModelName': 'qwen3-32b'
}
},
DeploymentInstanceType='ml.g6.48xlarge',
MaxInstanceCount=4,
OptimizationConfigs=[
{
'ModelSpeculativeDecodingConfig': {
'Technique': 'EAGLE',
'TrainingDataSource': {
'S3Uri': 's3://my-bucket/training_data/ultrachat_1k/',
'S3DataType': 'S3Prefix'
}
}
}
],
OutputConfig={
'S3OutputLocation': 's3://my-bucket/optimized-models/qwen3-optim-output/',
},
StoppingCondition={
'MaxRuntimeInSeconds': 432000 # 5 days
}
)
print(f"Optimization job ARN: {optimization_response['OptimizationJobArn']}")
```
**例: 最適化ジョブのモニタリングと管理**
最適化ジョブを作成したら、次のコマンドを使用してその進行状況をモニタリングし、管理できます。
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name='us-west-2')
# Describe optimization job to check status
describe_response = sagemaker_client.describe_optimization_job(
OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
)
print(f"Job Status: {describe_response['OptimizationJobStatus']}")
# List all optimization jobs (with pagination)
list_response = sagemaker_client.list_optimization_jobs(
MaxResults=10,
SortBy='CreationTime',
SortOrder='Descending'
)
print("\nRecent optimization jobs:")
for job in list_response['OptimizationJobSummaries']:
print(f"- {job['OptimizationJobName']}: {job['OptimizationJobStatus']}")
# Stop a running optimization job if needed
# sagemaker_client.stop_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
# Delete a completed or failed optimization job
# sagemaker_client.delete_optimization_job(
# OptimizationJobName='llama-optim-job-eagle-speculative-decoding'
# )
```
Eagle Heads による投機的デコードは、4 つのシーケンシャルトレーニングジョブを実行します。各ジョブは、次のジョブへの入力となる出力を生成します。最終ジョブからの出力のみが S3 バケットに配信されます。中間出力は暗号化され、内部 SageMaker AI サービスバケットに最大 20 日間保存されます。SageMaker AI には、それらを復号するアクセス許可がありません。その期間より前に中間データを削除する場合は、ジョブが完了または停止したことを確認し、このデータを削除するサポートケース [[https://docs.aws.amazon.com/awssupport/latest/user/case-management.html\$1creating-a-support-case](https://docs.aws.amazon.com/awssupport/latest/user/case-management.html#creating-a-support-case)] を開きます。 AWS アカウント ID と最適化ジョブ ARN をリクエストに含めます。
## SageMaker AI ドラフトモデルの制限事項
SageMaker AI ドラフトモデルで最適化するモデルについては、要件、制限、サポートされている環境変数に注意してください。
**要件**
以下を実行する必要があります。
+ SageMaker JumpStart に用意されているモデルを使用します。
+ モデルデプロイに対してネットワーク分離を有効にします。
+ モデルを大規模モデル推論 (LMI) コンテナにデプロイする場合は、バージョン 0.28.0 以降の DJLServing コンテナを使用します。
使用可能なコンテナについては、Deep Learning Containers GitHub リポジトリの「[Large Model Inference Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers)」を参照してください。
+ JumpStart モデルをファインチューニングする場合は、モデルの重みに Safetensor 形式を使用します。
この形式の詳細については、Hugging Face ドキュメントの「[Safetensors](https://huggingface.co/docs/safetensors/en/index)」を参照してください。
**制限事項**
次のことはできません。
+ ローカルモードで作成したローカルテスト環境でモデルを使用する。
ローカルモードの詳細については、SageMaker AI Python SDK ドキュメントの「[ローカルモード](https://sagemaker.readthedocs.io/en/stable/overview.html#local-mode)」を参照してください。
+ AWS Systems Manager エージェント (SSM エージェント) を介してモデルコンテナにアクセスします。SSM エージェントはモデルコンテナへのシェルレベルのアクセスを提供するため、Amazon CloudWatch でプロセスをデバッグし、コマンドをログに記録できます。
この機能の詳細については、「[SSM 経由でコンテナにアクセスする](ssm-access.md)」を参照してください。
+ プロセスがクラッシュした場合に発生するコアダンプのモデルコンテナを設定する。
モデルコンテナからのコアダンプの詳細については、「[ProductionVariantCoreDumpConfig](sagemaker/latest/APIReference/API_ProductionVariantCoreDumpConfig.html)」を参照してください。
+ モデルをマルチモデルエンドポイント、マルチコンテナエンドポイント、または推論コンポーネントをホストするエンドポイントにデプロイする。
これらのエンドポイントタイプについては、「[マルチモデルエンドポイント](multi-model-endpoints.md)」、「[マルチコンテナエンドポイント](multi-container-endpoints.md)」、「[推論コンポーネント](realtime-endpoints-deploy-models.md#inference-components)」を参照してください。
+ モデル用のモデルパッケージを作成する。モデルパッケージを使用して、公開するデプロイ可能なモデルを作成します AWS Marketplace。
この機能の詳細については、「[モデルパッケージのリソースを作成する](sagemaker-mkt-create-model-package.md)」を参照してください。
+ モデルコンテナで独自の推論コードを使用する。
+ モデルコンテナで `requirements.txt` ファイルを使用する。このタイプのファイルにはパッケージの依存関係が一覧表示されます。
+ Hugging Face パラメータ `trust_remote_code` を有効にする。
**サポートされている環境変数**
次の環境変数ではコンテナのみを設定できます。
+ 大規模モデル推論 (LMI) コンテナの一般的な環境変数。
これらの変数の詳細については、LMI コンテナドキュメントの「[Environment Variable Configurations](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/deployment_guide/configurations.html#environment-variable-configurations)」を参照してください。
+ Hugging Face Hub が Git リポジトリで提供しているパッケージの一般的な環境変数。
リポジトリについては、GitHub の「[Hugging Face](https://github.com/huggingface)」を参照してください。
+ 一般的な PyTorch および CUDA 環境変数。
これらの変数の詳細については、PyTorch ドキュメントの「[Torch Environment Variables](https://pytorch.org/docs/stable/torch_environment_variables.html)」を参照してください。
# 最適化ジョブの結果を表示する
1 つ以上の最適化ジョブを作成したら、Studio を使用してすべてのジョブの概要テーブルを表示し、個々のジョブの詳細を表示できます。
## Amazon SageMaker Studio
**最適化ジョブの概要テーブルを表示するには**
+ Studio ナビゲーションメニューの **[ジョブ]** で、**[推論最適化]** を選択します。
**[推論最適化]** ページにテーブルが表示され、作成したジョブを確認できます。ジョブごとに、適用した最適化設定とジョブのステータスが表示されます。
**ジョブの詳細を表示するには**
+ **[推論最適化]** ページの概要テーブルで、ジョブの名前を選択します。
Studio にジョブの詳細ページが表示され、ジョブのステータスと、ジョブの作成時に適用したすべての設定を確認できます。ジョブが正常に完了すると、SageMaker AI は最適化されたモデルアーティファクトを **[最適化されたモデルの S3 URI]** の Amazon S3 の場所に保存します。
# 最適化されたモデルのパフォーマンスを評価する
最適化ジョブを使用して最適化されたモデルを作成したら、モデルのパフォーマンスの評価を実行できます。この評価により、レイテンシー、スループット、および料金のメトリクスが得られます。これらのメトリクスを使用すると、最適化されたモデルがユースケースのニーズを満たしているかどうか、またはさらなる最適化が必要かどうかを判断できます。
パフォーマンス評価を実行できるのは、Studio のみです。この機能は、Amazon SageMaker AI API または Python SDK には搭載されていません。
## [開始する前に]
パフォーマンス評価を作成する前に、まず推論最適化ジョブを作成してモデルを最適化する必要があります。Studio で評価できるのは、これらのジョブで作成したモデルのみです。
## パフォーマンス評価を作成する
Studio で次の手順を実行して、最適化されたモデルのパフォーマンス評価を作成します。
1. Studio ナビゲーションメニューの **[ジョブ]** で、**[推論最適化]** を選択します。
1. 評価する最適化モデルを作成したジョブの名前を選択します。
1. ジョブの詳細ページで、**[パフォーマンスの評価]** を選択します。
1. 一部の JumpStart モデルでは、**[パフォーマンスの評価]** ページで、続行する前にエンドユーザーライセンス契約 (EULA) に署名する必要があります。要求された場合、**[ライセンス契約]** セクションのライセンス条項を確認してください。その条項がユースケースで受け入れられる場合は、**[EULA に同意し、利用規約を読みました]** のチェックボックスをオンにします。
1. **[トークナイザーのモデルを選択]** では、デフォルトを受け入れるか、評価のトークナイザーとして機能する特定のモデルを選択します。
1. **[入力データセット]** では、以下の手順を実行するどうかを選択します。
+ SageMaker AI のデフォルトのサンプルデータセットを使用する。
+ 独自のサンプルデータセットを指す S3 URI を指定する。
1. **[パフォーマンス結果の S3 URI]** では、評価結果を保存する Amazon S3 の場所を指す URI を指定します。
1. **[評価]** を選択します。
Studio に **[パフォーマンス評価]** ページが表示され、評価ジョブを確認できます。**[ステータス]** 列には、評価のステータスが表示されます。
1. ステータス **[完了済み]** になったら、ジョブの名前を選択して評価結果を表示します。
評価の詳細ページには、レイテンシー、スループット、および料金のパフォーマンスメトリクスが含まれているテーブルが表示されます。各メトリクスの詳細については、「[推論パフォーマンス評価のメトリクスのリファレンス](#performance-eval-metrics-reference)」を参照してください。
## 推論パフォーマンス評価のメトリクスのリファレンス
最適化モデルのパフォーマンスを正常に評価すると、Studio の評価の詳細ページに次のメトリクスが表示されます。
### レイテンシーメトリクス
**[レイテンシー]** セクションには、次のメトリクスが表示されます。
**同時実行**
エンドポイントを同時に呼び出すために評価がシミュレートした同時ユーザーの数。
**最初のトークンまでの時間 (ミリ秒)**
リクエストが送信されてからストリーミングレスポンスの最初のトークンが受信されるまでに経過した時間。
**トークン間レイテンシー (ミリ秒)**
リクエストごとに出力トークンを生成する時間。
**クライアントレイテンシー (ミリ秒)**
リクエストが送信されてからレスポンス全体が受信されるまでのリクエストレイテンシー。
**入力トークン/秒 (数)**
すべてのリクエストで生成された入力トークンの合計数を、同時実行の合計時間 (秒単位) で割った値。
**出力トークン/秒 (数)**
すべてのリクエストで生成された出力トークンの合計数を、同時実行の合計時間 (秒単位) で割った値。
**クライアント呼び出し (数)**
同時実行時にすべてのユーザーにエンドポイントに送信された推論リクエストの合計数。
**クライアント呼び出しエラー (数)**
呼び出しエラーが発生した特定の同時実行時に、すべてのユーザーにエンドポイントに送信された推論リクエストの合計数。
**トークン化に失敗 (数)**
トークナイザーがリクエストまたはレスポンスの解析に失敗した推論リクエストの総数。
**空の推論レスポンス (数)**
出力トークンがゼロになったか、トークナイザーがレスポンスの解析に失敗した推論リクエストの合計数。
### スループットメトリクス
**[スループット]** セクションには、次のメトリクスが表示されます。
**同時実行**
エンドポイントを同時に呼び出すために評価がシミュレートした同時ユーザーの数。
**入力トークン/秒/リクエスト (数)**
リクエストごとの 1 秒あたりに生成された入力トークンの合計数。
**出力トークン/秒/リクエスト (数)**
リクエストごとの 1 秒あたりに生成された出力トークンの合計数。
**入力トークン (数)**
リクエストごとに生成された入力トークンの合計数。
**出力トークン (数)**
リクエストごとに生成された出力トークンの合計数。
### 料金メトリクス
**[料金]** セクションには、次のメトリクスが表示されます。
**同時実行**
エンドポイントを同時に呼び出すために評価がシミュレートした同時ユーザーの数。
**100 万入力トークンあたりの料金**
100 万入力トークンの処理コスト。
**100 万出力トークンあたりの料金**
100 万出力トークンの生成コスト。
# サポートされているモデルリファレンス
次の表に、SageMaker AI が推論最適化をサポートしているモデルと、サポートされている最適化手法を示します。
**サポートされている Llama モデル**
| モデル名 | 量子化でサポートされているデータ形式 | 投機的デコーディングをサポート | 高速モデルロードをサポート | コンパイルに使用されるライブラリ |
| --- | --- | --- | --- | --- |
| Meta Llama 2 13B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Llama 2 13B Chat | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Llama 2 70B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Llama 2 70B Chat | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Llama 2 7B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Llama 2 7B Chat | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Llama 3 70B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Llama 3 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Llama 3 8B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Llama 3 8B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Meta Code Llama 13B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 13B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 13B Python | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 34B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 34B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 34B Python | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 70B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 70B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 70B Python | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 7B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Code Llama 7B Python | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Meta Llama 2 13B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 2 13B Chat Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 2 70B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 2 70B Chat Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 2 7B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 2 7B Chat Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 3 70B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 3 70B Instruct Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 3 8B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 3 8B Instruct Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Code Llama 70B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Code Llama 7B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Code Llama 7B Python Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 3.1 405B FP8 | なし | はい | はい | なし |
| Meta Llama 3.1 405B Instruct FP8 | なし | はい | はい | なし |
| Meta Llama 3.1 70B | INT4-AWQ FP8 | はい | はい | なし |
| Meta Llama 3.1 70B Instruct | INT4-AWQ FP8 | はい | はい | なし |
| Meta Llama 3.1 8B | INT4-AWQ FP8 | はい | はい | なし |
| Meta Llama 3.1 8B Instruct | INT4-AWQ FP8 | はい | はい | なし |
| Meta Llama 3.1 70B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 3.1 70B Instruct Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 3 1 8B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Meta Llama 3.1 8B Instruct Neuron | なし | いいえ | 不可 | AWSニューロン |
**サポートされている Mistral モデル**
| モデル名 | 量子化でサポートされているデータ形式 | 投機的デコーディングをサポート | 高速モデルロードをサポート | コンパイルに使用されるライブラリ |
| --- | --- | --- | --- | --- |
| Mistral 7B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Mistral 7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | AWSニューロン TensorRT-LLM |
| Mistral 7B Neuron | なし | いいえ | 不可 | AWSニューロン |
| Mistral 7B Instruct Neuron | なし | いいえ | 不可 | AWSニューロン |
**サポートされている Mixtral モデル**
| モデル名 | 量子化でサポートされているデータ形式 | 投機的デコーディングをサポート | 高速モデルロードをサポート | コンパイルに使用されるライブラリ |
| --- | --- | --- | --- | --- |
| Mixtral-8x22B-Instruct-v0.1 | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Mixtral-8x22B V1 | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Mixtral 8x7B | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
| Mixtral 8x7B Instruct | INT4-AWQ INT8-SmoothQuant FP8 | はい | はい | TensorRT-LLM |
**サポートされているモデルアーキテクチャと EAGLE タイプ**
| モデルアーキテクチャ名 | EAGLE タイプ |
| --- | --- |
| LlamaForCausalLM | EAGLE 3 |
| Qwen3ForCausalLM | EAGLE 3 |
| Qwen3NextForCausalLM | EAGLE 2 |
| Qwen3MoeForCausalLM | EAGLE 3 |
| Qwen2ForCausalLM | EAGLE 3 |
| GptOssForCausalLM | EAGLE 3 |
# Amazon SageMaker AI で機械学習モデルを評価するオプション
モデルをトレーニングした後、そのパフォーマンスと正確性がビジネス目標を達成可能かどうか判断するために、モデルを評価します。さまざまな方法で複数のモデルを生成し、それぞれを評価することができます。例えば、モデルごとに異なるビジネスルールを適用し、さまざまな尺度を適用して各モデルの適合性を判断することができます。モデルが特定のものよりも敏感である必要があるかどうか (またはその逆) を検討することができます。
履歴データ (オフラインの場合) またはライブデータを使用してモデルを評価できます。
+ **オフラインテスト** - モデルに推論のリクエストを送信するために、ライブデータではなく過去データを使用します。
トレーニングを受けたモデルをアルファエンドポイントにデプロイし、履歴データを使用して推論リクエストを送信します。リクエストを送信するには、Amazon SageMaker AI ノートブックインスタンスで Jupyter Notebook を使用し、 AWS SDK for Python (Boto) または SageMaker AI が提供する高レベルの Python ライブラリを使用します。
+ **ライブデータを使用したオンラインテスト** — SageMaker AI は、本番バリアントを使用することで、稼働中のモデルの A/B テストをサポートします。本番バリアントは、同じ推論コードを使用し、同じ SageMaker AI エンドポイントにデプロイされるモデルです。検証するモデルにライブトラフィックのごく一部が移動するように、本番バリアントを設定します。例えば、評価のためにトラフィックの 10% をモデルのバリエーションに送信することを選択できます。モデルのパフォーマンスに満足したら、更新されたモデルに 100% のトラフィックをルーティングできます。本番稼働でのモデルのテストの例については、「[本番稼働用バリアントを使用してモデルをテストする](model-ab-testing.md)」を参照してください。
詳細については、[Evaluating Machine Learning Models (機械学習モデルの評価)](http://www.oreilly.com/data/free/evaluating-machine-learning-models.csp) など、モデルの評価方法に関する記事や書籍を参照してください。
オフラインモデル評価のオプションは次のとおりです。
+ **保留セットを使用して検証する** - 機械学習の実践者は、データの一部を「保留セット」として残しておくことがよくあります。モデルのトレーニングにこのデータを使用しません。
このアプローチでは、モデルが保留セットに関する推論をどの程度適切に提供するかを評価します。次に、モデルのメモリを使用するのではなく、モデルが最初のトレーニングで学習したことをどの程度効果的に一般化しているかを評価します。この検証方法は、モデルが正しい答えをどれくらいの頻度で推論できるかを示します。
いくつかの点で、このアプローチは小学生を教えることに似ています まず、学習するための一連の例を提供し、学習から一般化する能力をテストします。宿題とテストでは、最初の学習に含まれていなかった問題を提起し、彼らが効果的に一般化できるかどうかを判断します。完璧な記憶を持つ生徒は、ルールを学習する代わりに、問題を暗記することができます。
通常、保留データセットはトレーニングデータの 20～30% です。
+ **K 分割検証** - この検証手法では、サンプルデータセットを k 個の部分に分割します。**このそれぞれを、*k* 回のトレーニング実行のための保留セットとみなし、他の *k*-1 個の部分をそのトレーニング実行のためのトレーニングセットとして使用します。同様のプロセスを使用して *k* 個のモデルを作成し、モデルを集約して最終モデルを生成します。*k* は通常、5 ～ 10 の範囲の値です。
# Amazon SageMaker Inference Recommender
Amazon SageMaker Inference Recommender は Amazon SageMaker AI の機能です。SageMaker AI ML インスタンス間でロードテストとモデル調整を自動化することによって、本番環境で機械学習 (ML) モデルを取得するのに必要な時間を短縮します。Inference Recommender を使用して、リアルタイムまたはサーバーレスの推論エンドポイントにモデルをデプロイすれば、最小のコストでベストパフォーマンスを実現できます。Inference Recommender は、機械学習モデルとワークロードに最適なインスタンスタイプと設定を選択するのに役立ちます。インスタンス数、コンテナパラメータ、モデル最適化、最大同時実行数、メモリサイズなどの要因を考慮します。
Amazon SageMaker Inference Recommender は、ジョブの実行中に使用されたインスタンスに対してのみ課金されます。
## 仕組み
Amazon SageMaker Inference Recommender を使用するには、[SageMaker AI モデルを作成するか](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)、モデルアーティファクトを使用してモデルを SageMaker モデルレジストリに登録します。 AWS SDK for Python (Boto3) または SageMaker AI コンソールを使用して、さまざまな SageMaker AI エンドポイント構成のベンチマークジョブを実行します。推論レコメンダージョブは、パフォーマンスとリソース使用率に関するメトリクスを収集して視覚化し、どのエンドポイントタイプと構成を選択するかを決定するのに役立ちます。
## 開始方法
Amazon SageMaker Inference Recommender を初めて使用する方には、次のことをお勧めします。
1. 「[Amazon SageMaker Inference Recommender を使用するための前提条件](inference-recommender-prerequisites.md)」セクションを参照し、Amazon SageMaker Inference Recommender を使用するための要件を満たしていることを確認します。
1. 「[Amazon SageMaker Inference Recommender を使用したレコメンデーションジョブ](inference-recommender-recommendation-jobs.md)」セクションを参照し、最初の推論レコメンダーのレコメンデーションジョブを開始します。
1. 入門者向けの Amazon SageMaker Inference Recommender [Jupyter Notebook](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-inference-recommender/inference-recommender.ipynb) の例を試すか、次のセクションでノートブックのサンプルを確認してください。
## サンプルノートブックの例
以下の Jupyter Notebook の例は、Inference Recommender の複数のユースケースのワークフローに役立ちます。
+ TensorFlow モデルをベンチマークする入門用ノートブックが必要な場合は、[SageMaker Inference Recommender TensorFlow](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/inference-recommender.ipynb) ノートブックを参照してください。
+ HuggingFace モデルをベンチマークする場合は、[SageMaker Inference Recommender for HuggingFace](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/huggingface-inference-recommender/huggingface-inference-recommender.ipynb) ノートブックを参照してください。
+ XGBoost モデルをベンチマークする場合は、[SageMaker Inference Recommender XGBoost](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/xgboost/xgboost-inference-recommender.ipynb) ノートブックを参照してください。
+ Inference Recommender のジョブの CloudWatch メトリクスを確認する場合は、[SageMaker Inference Recommender CloudWatch メトリクス](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/tensorflow-cloudwatch/tf-cloudwatch-inference-recommender.ipynb)ノートブックを参照してください。
# Amazon SageMaker Inference Recommender を使用するための前提条件
Amazon SageMaker Inference Recommender を使用する前に、前提条件ステップを完了させる必要があります。例として、両方のタイプの Amazon SageMaker Inference Recommender レコメンデーションジョブに対して、PyTorch (v1.7.1) ResNet-18 の事前学習済みモデルを使用する方法を示します。ここに示す例では AWS SDK for Python (Boto3)を使用しています。
**注記**
次のコード例では Python を使用しています。ターミナルまたは AWS CLIで次のコードサンプルのいずれかを実行する場合は、`!` プレフィックスを削除します。
Amazon SageMaker Studio ノートブックで Python 3 (TensorFlow 2.6 Python 3.8 CPU 最適化) カーネルを使用して、次の例を実行できます。Studio の詳細については、「[Amazon SageMaker Studio](studio-updated.md)」を参照してください。
1. **Amazon SageMaker AI 用の IAM ロールを作成する。**
`AmazonSageMakerFullAccess` IAM マネージドポリシーがアタッチされている Amazon SageMaker AI の IAM ロールを作成します。
1. **環境をセットアップします。**
依存関係をインポートし AWS リージョン、 、SageMaker AI IAM ロール (ステップ 1 から）、および SageMaker AI クライアントの変数を作成します。
```
!pip install --upgrade pip awscli botocore boto3 --quiet
from sagemaker import get_execution_role, Session, image_uris
import boto3
region = boto3.Session().region_name
role = get_execution_role()
sagemaker_client = boto3.client("sagemaker", region_name=region)
sagemaker_session = Session()
```
1. **(オプション) Inference Recommender によってベンチマークされた既存のモデルを確認します。**
Inference Recommender は、人気のあるモデルズーのモデルをベンチマークします。Inference Recommender は、まだベンチマークされていないモデルもサポートします。
`ListModelMetaData` を使用して、一般的なモデルズーで見つかった機械学習モデルのドメイン、フレームワーク、タスク、モデル名を一覧表示するレスポンスオブジェクトを取得します。
後のステップでドメイン、フレームワーク、フレームワークのバージョン、タスク、モデル名を使用して、推論 Docker イメージを選択し、モデルを SageMaker Model Registry に登録します。以下は、SDK for Python (Boto3) を使用してモデルメタデータを一覧表示する方法を示しています。
```
list_model_metadata_response=sagemaker_client.list_model_metadata()
```
出力には、以下の例のようなモデルのサマリー (`ModelMetadataSummaries`) とレスポンスメタデータ (`ResponseMetadata`) が含まれます。
```
{
'ModelMetadataSummaries': [{
'Domain': 'NATURAL_LANGUAGE_PROCESSING',
'Framework': 'PYTORCH:1.6.0',
'Model': 'bert-base-cased',
'Task': 'FILL_MASK'
},
{
'Domain': 'NATURAL_LANGUAGE_PROCESSING',
'Framework': 'PYTORCH:1.6.0',
'Model': 'bert-base-uncased',
'Task': 'FILL_MASK'
},
{
'Domain': 'COMPUTER_VISION',
'Framework': 'MXNET:1.8.0',
'Model': 'resnet18v2-gluon',
'Task': 'IMAGE_CLASSIFICATION'
},
{
'Domain': 'COMPUTER_VISION',
'Framework': 'PYTORCH:1.6.0',
'Model': 'resnet152',
'Task': 'IMAGE_CLASSIFICATION'
}],
'ResponseMetadata': {
'HTTPHeaders': {
'content-length': '2345',
'content-type': 'application/x-amz-json-1.1',
'date': 'Tue, 19 Oct 2021 20:52:03 GMT',
'x-amzn-requestid': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
},
'HTTPStatusCode': 200,
'RequestId': 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx',
'RetryAttempts': 0
}
}
```
このデモでは、PyTorch (v1.7.1) ResNet-18 モデルを使用してイメージ分類を実行します。次の Python コードサンプルでは、フレームワーク、フレームワークのバージョン、ドメイン、タスクを変数に格納して、後で使用できるようにします。
```
# ML framework details
framework = 'pytorch'
framework_version = '1.7.1'
# ML model details
ml_domain = 'COMPUTER_VISION'
ml_task = 'IMAGE_CLASSIFICATION'
```
1. **Amazon S3 に機械学習モデルをアップロードします。**
事前トレーニング済みの機械学習モデルがない場合は、この PyTorch (v1.7.1) ResNet-18 モデルを使用してください。
```
# Optional: Download a sample PyTorch model
import torch
from torchvision import models, transforms, datasets
# Create an example input for tracing
image = torch.zeros([1, 3, 256, 256], dtype=torch.float32)
# Load a pretrained resnet18 model from TorchHub
model = models.resnet18(pretrained=True)
# Tell the model we are using it for evaluation (not training). Note this is required for Inferentia compilation.
model.eval()
model_trace = torch.jit.trace(model, image)
# Save your traced model
model_trace.save('model.pth')
```
サンプル推論スクリプト `inference.py` をダウンロードします。`code` ディレクトリを作成して、推論スクリプトを `code` ディレクトリに移動します。
```
# Download the inference script
!wget https://aws-ml-blog-artifacts.s3.us-east-2.amazonaws.com/inference.py
# move it into a code/ directory
!mkdir code
!mv inference.py code/
```
Amazon SageMaker AI では、事前学習済みの機械学習モデルを圧縮 TAR ファイル (`*.tar.gz`) としてパッケージ化する必要があります。この要件を満たすようにモデルと推論スクリプトを圧縮します。
```
!tar -czf test.tar.gz model.pth code/inference.py
```
エンドポイントがプロビジョニングされると、アーカイブ内のファイルが抽出され、エンドポイントの `/opt/ml/model/` に抽出されます。
モデルとモデルのアーティファクトを`.tar.gz` ファイルとして圧縮したら、それらを Amazon S3 バケットにアップロードします。以下の例は、 AWS CLIを使用して Amazon S3 にモデルをアップロードする方法を示しています。
```
!aws s3 cp test.tar.gz s3://{your-bucket}/models/
```
1. **構築済みの Docker 推論イメージを選択するか、独自の推論 Docker イメージを作成する。**
SageMaker AI は、Apache MXNet、TensorFlow、PyTorch、Chainer など、いくつかの最も一般的な機械学習フレームワーク用に、組み込みアルゴリズムおよび構築済みの Docker イメージのコンテナを提供しています。使用可能な SageMaker AI イメージの完全なリストについては、「[Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md)」を参照してください。
既存の SageMaker AI コンテナがニーズを満たしておらず、独自の既存のコンテナがない場合は、新しい Docker イメージを作成します。Docker イメージを作成する方法については、「[カスタム推論コードを持つコンテナ](your-algorithms-inference-main.md)」を参照してください。
以下に、SageMaker Python SDK を使用して PyTorch バージョン 1.7.1 推論イメージを取得する方法を示します。
```
from sagemaker import image_uris
## Uncomment and replace with your own values if you did not define
## these variables a previous step.
#framework = 'pytorch'
#framework_version = '1.7.1'
# Note: you can use any CPU-based instance here,
# this is just to set the arch as CPU for the Docker image
instance_type = 'ml.m5.2xlarge'
image_uri = image_uris.retrieve(framework,
region,
version=framework_version,
py_version='py3',
instance_type=instance_type,
image_scope='inference')
```
使用可能な SageMaker AI インスタンスのリストについては、「[Amazon SageMaker AI Pricing](https://aws.amazon.com/sagemaker/pricing/)」を参照してください。
1. **サンプルペイロードアーカイブを作成します。**
ロードテストツールが SageMaker AI エンドポイントに送信できる個別のファイルを含むアーカイブを作成します。推論コードは、サンプルペイロードからファイル形式を読み取り可能である必要がります。
次の例では、この例の後のステップで ResNet-18 モデルに使用する.jpg イメージをダウンロードします。
```
!wget https://cdn.pixabay.com/photo/2020/12/18/05/56/flowers-5841251_1280.jpg
```
サンプルペイロードを tarball として圧縮します。
```
!tar -cvzf payload.tar.gz flowers-5841251_1280.jpg
```
サンプルペイロードを Amazon S3 にアップロードし、Amazon S3 URI を書き留めます。
```
!aws s3 cp payload.tar.gz s3://{bucket}/models/
```
Amazon S3 URI は後のステップで必要になるため、変数に格納します。
```
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
payload_s3_key = f"{bucket_prefix}/payload.tar.gz"
sample_payload_url= f"s3://{bucket}/{payload_s3_key}"
```
1. **レコメンデーションジョブ向けにモデルの入力を準備します。**
最後の前提条件として、モデルの入力を準備するための 2 つのオプションがあります。モデルを SageMaker Model Registry に登録し、これを使用して本番稼働用にモデルをカタログ化するか、SageMaker AI モデルを作成して、レコメンデーションジョブの作成時に `ContainerConfig` フィールドに指定できます。最初のオプションは、モデルバージョンの管理やモデルのデプロイの自動化など、[Model Registry](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry.html) が備えている機能を利用する場合に最適です。2 番目のオプションは、すぐに使い始める必要がある場合に最適です。1 つ目のオプションを選択する場合は、ステップ 7 に進みます。2 つ目のオプションを選択する場合は、ステップ 7 をスキップしてステップ 8 に進みます。
1. **オプション 1: モデルをモデルレジストリに登録します**
SageMaker Model Registry を使用すると、本番用のモデルのカタログ化、モデルバージョンの管理、メタデータ (トレーニング指標など) のモデルへの関連付け、モデルの承認ステータスの管理、モデルの本番環境へのデプロイ、CI/CD を使用したモデル展開の自動化を行えます。
SageMaker モデルレジストリを使用してモデルを追跡および管理する場合は、モデルパッケージグループ内のバージョン管理されたモデルパッケージとして表されます。バージョン管理されていないモデルパッケージは、モデルグループの一部ではありません。モデルパッケージグループは、モデルの複数のバージョンまたはイテレーションを保持します。レジストリ内のすべてのモデルに対してそれらを作成する必要はありませんが、それらはすべて同じ目的を持つさまざまなモデルを整理し、自動バージョニングを提供するのに役立ちます。
Amazon SageMaker Inference Recommender を使用するには、バージョン管理されたモデルパッケージが必要です。バージョン管理されたモデルパッケージは、 AWS SDK for Python (Boto3) または Amazon SageMaker Studio Classic を使用してプログラムで作成できます。バージョン管理されたモデルパッケージをプログラムで作成するには、まずモデルパッケージグループを `CreateModelPackageGroup` API で作成します。次に、`CreateModelPackage` API を使用してモデルパッケージを作成します。このメソッドを呼び出すと、バージョン管理されたモデルパッケージが作成されます。
[モデルグループを作成する](model-registry-model-group.md) および Amazon SageMaker Studio Classic を使用して、プログラムおよびインタラクティブにモデルパッケージグループを作成する方法と、それぞれバージョニングされたモデルパッケージを作成する方法[モデルバージョンを登録する](model-registry-version.md)の詳細については、 AWS SDK for Python (Boto3) 「」および「」を参照してください。
次のコードサンプルは、 AWS SDK for Python (Boto3)を使用して、バージョン管理されたモデルパッケージを作成する方法を示します。
**注記**
Inference Recommender ジョブを作成するために、モデルパッケージを承認する必要はありません。
1. **モデルパッケージグループを作成する**
`CreateModelPackageGroup` API を使用して、モデルパッケージグループを作成します。モデルパッケージグループの `ModelPackageGroupName` に名前を付け、必要に応じてモデルパッケージの説明を `ModelPackageGroupDescription` フィールドに指定します。
```
model_package_group_name = ''
model_package_group_description = ''
model_package_group_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageGroupDescription" : model_package_group_description,
}
model_package_group_response = sagemaker_client.create_model_package_group(**model_package_group_input_dict)
```
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackageGroup.html) に渡すことができるオプションの引数と必須の引数の完全なリストについては、[Amazon SageMaker API リファレンスガイド](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html)を参照してください。
推論コードを実行する Docker イメージとモデルアーティファクトの Amazon S3 の場所を指定して、モデルパッケージを作成し、`InferenceSpecification` の値を指定します。`InferenceSpecification` には、このモデルパッケージに基づいてモデルで実行できる推論ジョブに関する情報が含まれている必要があります。その内容は次のとおりです。
+ 推論コードを実行するイメージの Amazon ECR パス。
+ (オプション) モデルパッケージが推論に使用される変換ジョブとリアルタイムエンドポイントでサポートするインスタンスタイプ。
+ モデルパッケージが推論でサポートする入力および出力コンテンツ形式。
モデルパッケージを作成するときは、次のパラメータも指定する必要があります。
+ [Domain](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Domain): モデルパッケージとそのコンポーネントの機械学習ドメイン。一般的な機械学習ドメインは、コンピュータビジョンと自然言語処理が含まれます。
+ [Task](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Task): モデルパッケージが実行する機械学習タスク。一般的な機械学習タスクには、物体検出とイメージ分類が含まれます。[API リファレンスガイド](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html)に記載されているどのタスクもユースケースを満たさない場合は、「OTHER」を指定してください。[サポートされている機械学習タスクのリストについては、Task](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-Task) API フィールドの説明を参照してください。
+ [SamplePayloadUrl](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-SamplePayloadUrl): サンプルペイロードが保存される Amazon Simple Storage Service (Amazon S3) パス。このパスは GZIP で圧縮された単一の TAR アーカイブ (サフィックスは .tar.gz) を指す必要があります。
+ [Framework](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageContainerDefinition.html#sagemaker-Type-ModelPackageContainerDefinition-Framework): モデルパッケージコンテナイメージの機械学習フレームワーク。
+ [FrameworkVersion](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelPackageContainerDefinition.html#sagemaker-Type-ModelPackageContainerDefinition-FrameworkVersion): モデルパッケージコンテナイメージのフレームワークバージョン。
[SupportedRealtimeInferenceInstanceTypes](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InferenceSpecification.html#sagemaker-Type-InferenceSpecification-SupportedRealtimeInferenceInstanceTypes) の推論をリアルタイムで生成するために使用するインスタンスタイプの許可リストを指定すると、Inference Recommender は `Default` ジョブ中、インスタンスタイプの探索空間を制限します。予算に制約がある場合、またはモデルとコンテナイメージをサポートできる特定のインスタンスタイプのセットが存在することがわかっている場合は、このパラメータを使用します。
前のステップでは、トレーニング済みの ResNet18 モデルをダウンロードし、`models` というディレクトリの Amazon S3 バケットに保存しました。PyTorch (v1.7.1) Deep Learning Containers 推論イメージを取得し、その URI を `image_uri` という変数に格納しました。これらの変数を次のコードサンプルで使用して、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html) API への入力として使用するディクショナリを定義します。
```
# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"
# Similar open source model to the packaged model
# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'
# The supported MIME types for input and output data. In this example,
# we are using images as input.
input_content_type='image/jpeg'
# Optional - provide a description of your model.
model_package_description = ''
## Uncomment if you did not store the domain and task in an earlier
## step
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'
## Uncomment if you did not store the framework and framework version
## in a previous step.
#framework = 'PYTORCH'
#framework_version = '1.7.1'
# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"
# Create a dictionary to use as input for creating a model pacakge group
model_package_input_dict = {
"ModelPackageGroupName" : model_package_group_name,
"ModelPackageDescription" : model_package_description,
"Domain": ml_domain,
"Task": ml_task,
"SamplePayloadUrl": sample_payload_url,
"InferenceSpecification": {
"Containers": [
{
"Image": image_uri,
"ModelDataUrl": model_url,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": nearest_model_name,
"ModelInput": {"DataInputConfig": data_input_configuration}
}
],
"SupportedContentTypes": [input_content_type]
}
}
```
1. **モデルパッケージを作成する**
`CreateModelPackage` API を使用してモデルパッケージを作成します。前のステップで定義した入力ディクショナリを渡します。
```
model_package_response = sagemaker_client.create_model_package(**model_package_input_dict)
```
Amazon SageMaker Inference Recommender を使用するには、モデルパッケージ ARN が必要です。モデルパッケージの ARN を書き留めるか、変数に格納します。
```
model_package_arn = model_package_response["ModelPackageArn"]
print('ModelPackage Version ARN : {}'.format(model_package_arn))
```
1. **オプション 2: モデルを作成して `ContainerConfig` フィールドを設定します**
推論レコメンデーションジョブを開始する際、モデルをモデルレジストリに登録する必要がない場合は、このオプションを使用します。次のステップでは、SageMaker AI でモデルを作成し、`ContainerConfig` フィールドをレコメンデーションジョブの入力として設定します。
1. **モデルを作成する**
`CreateModel` API を使用してモデルを作成します。SageMaker AI Hosting にモデルをデプロイする際にこのメソッドを呼び出す例については、「[Create a Model (AWS SDK for Python (Boto3))](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html#realtime-endpoints-deployment-create-model)」を参照してください。
前のステップでは、トレーニング済みの ResNet18 モデルをダウンロードし、`models` というディレクトリの Amazon S3 バケットに保存しました。PyTorch (v1.7.1) Deep Learning Containers 推論イメージを取得し、その URI を `image_uri` という変数に格納しました。これらの変数を次のコードサンプルで使用します。ここでは、`[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html#sagemaker-CreateModel-request-ModelName)` API への入力として使用するディクショナリを定義します。
```
model_name = ''
# Role to give SageMaker permission to access AWS services.
sagemaker_role= "arn:aws:iam::::role/*"
# Provide the Amazon S3 URI of your compressed tarfile
# so that Model Registry knows where to find your model artifacts
bucket_prefix='models'
bucket = '' # Provide the name of your S3 bucket
model_s3_key = f"{bucket_prefix}/test.tar.gz"
model_url= f"s3://{bucket}/{model_s3_key}"
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': image_uri,
'ModelDataUrl': model_url,
})
```
1. **`ContainerConfig` フィールドを設定する**
次に、作成したモデルで [ContainerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RecommendationJobInputConfig.html#sagemaker-Type-RecommendationJobInputConfig-ContainerConfig) フィールドを設定し、そのフィールドに次のパラメータを指定する必要があります。
+ `Domain`: モデルとそのコンポーネント (コンピュータビジョンや自然言語処理など) の機械学習ドメイン。
+ `Task`: イメージ分類やオブジェクトの検出など、モデルが実行する機械学習タスク。
+ `PayloadConfig`: レコメンデーションジョブのペイロードの構成。サブフィールドの詳細については、「`[RecommendationJobPayloadConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_RecommendationJobPayloadConfig.html#sagemaker-Type-RecommendationJobPayloadConfig-SamplePayloadUrl)`」を参照してください。
+ `Framework`: PyTorch などのコンテナイメージの機械学習フレームワーク。
+ `FrameworkVersion`: コンテナイメージのフレームワークバージョン。
+ (オプション) `SupportedInstanceTypes`: 推論をリアルタイムで生成するために使用されるインスタンスタイプのリスト。
`SupportedInstanceTypes` パラメータを使用すると、Inference Recommender は `Default` ジョブ中にインスタンスタイプの探索空間を制限します。予算に制約がある場合、またはモデルとコンテナイメージをサポートできる特定のインスタンスタイプのセットが存在することがわかっている場合は、このパラメータを使用します。
次のコードサンプルでは、以前に定義したパラメータを `NearestModelName` と共に使用して、`[CreateInferenceRecommendationsJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html)` API への入力として使用するディクショナリを定義します。
```
## Uncomment if you did not store the domain and task in a previous step
#ml_domain = 'COMPUTER_VISION'
#ml_task = 'IMAGE_CLASSIFICATION'
## Uncomment if you did not store the framework and framework version in a previous step
#framework = 'PYTORCH'
#framework_version = '1.7.1'
# The name of the ML model as standardized by common model zoos
nearest_model_name = 'resnet18'
# The supported MIME types for input and output data. In this example,
# we are using images as input
input_content_type='image/jpeg'
# Optional: Used for optimizing your model using SageMaker Neo
# PyTorch uses NCHW format for images
data_input_configuration = "[[1,3,256,256]]"
# Create a dictionary to use as input for creating an inference recommendation job
container_config = {
"Domain": ml_domain,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": nearest_model_name,
"PayloadConfig": {
"SamplePayloadUrl": sample_payload_url,
"SupportedContentTypes": [ input_content_type ]
},
"DataInputConfig": data_input_configuration
"Task": ml_task,
}
```
# Amazon SageMaker Inference Recommender を使用したレコメンデーションジョブ
Amazon SageMaker Inference Recommender は、次の 2 種類のレコメンデーションを作成できます。
1. 推論レコメンデーション (`Default` ジョブタイプ) は、レコメンデーションインスタンスタイプに対して一連のロードテストを実行します。サーバーレスエンドポイントのロードテストを行うこともできます。モデルパッケージの Amazon リソースネーム (ARN) を指定するだけで、このタイプのレコメンデーションジョブを起動できます。推論レコメンデーションジョブは 45 分以内に完了します。
1. エンドポイントのレコメンデーション (`Advanced` ジョブタイプ) は、目的の機械学習インスタンスまたはサーバーレスエンドポイントを選択し、カスタムトラフィックパターンを指定して、本番環境要件に基づいてレイテンシーとスループットの要件を指定するカスタムロードテストに基づいています。このジョブの完了には、設定されたジョブ期間とテストされた推論設定の合計数に応じて、平均 2 時間かかります。
どちらのタイプのレコメンデーションも、同じ API を使用し、ジョブの作成、説明、停止を使用します。出力は、関連する環境変数、コスト、スループット、レイテンシーメトリクスに関連するインスタンス設定のレコメンデーションのリストです。レコメンデーションジョブは、オートスケーリングポリシーの設定に使用できる初期インスタンス数も提供します。2 つのタイプのジョブを区別するには、SageMaker AI コンソールまたは API を使用してジョブを作成する際に、`Default` を指定して予備的なエンドポイントレコメンデーションを作成し、カスタムロードテストとエンドポイントのレコメンデーションに `Advanced` を指定します。
**注記**
両方のタイプのレコメンデーションジョブを独自のワークフローで実行する必要はありません。どちらかから独立して行うことができます。
Inference Recommender では、想定インスタンスのリスト、またはモデルデプロイのコスト、スループット、レイテンシーが最適化された上位 5 つのインスタンスタイプを、信頼度スコアとともに提供することもできます。これらのインスタンスは、モデルをデプロイする際に選択できます。Inference Recommender はモデルに対して自動的にベンチマークを行い、想定インスタンスを提供します。これらは予備的なレコメンデーションであるため、より正確な結果を得るには、さらにインスタンスレコメンデーションジョブを実行することをお勧めします。想定インスタンスを表示するには、SageMaker AI モデルの詳細ページにアクセスしてください。詳細については、「[想定インスタンスを即時に入手する](inference-recommender-prospective.md)」を参照してください。
**Topics**
+ [想定インスタンスを即時に入手する](inference-recommender-prospective.md)
+ [推論レコメンデーション](inference-recommender-instance-recommendation.md)
+ [既存のエンドポイントの推論レコメンデーションを取得する](inference-recommender-existing-endpoint.md)
+ [推論レコメンデーションを停止する](instance-recommendation-stop.md)
+ [Neo でコンパイル済みのレコメンデーション](inference-recommender-neo-compilation.md)
+ [レコメンデーション結果](inference-recommender-interpret-results.md)
+ [自動スケーリングポリシーレコメンデーションを取得する](inference-recommender-autoscaling.md)
+ [カスタムロードテストを実行する](inference-recommender-load-test.md)
+ [ロードテストを停止する](load-test-stop.md)
+ [Inference Recommender エラーのトラブルシューティング](inference-recommender-troubleshooting.md)
# 想定インスタンスを即時に入手する
Inference Recommender では、SageMaker AI モデルの詳細ページに、想定インスタンス**のリスト、またはモデルに適していると考えられるインスタンスタイプが表示されます。Inference Recommender はモデルに対して自動的に予備的なベンチマークを行い、上位 5 つの想定インスタンスを提供します。これらは予備的なレコメンデーションであるため、より正確な結果を得るには、さらにインスタンスレコメンデーションジョブを実行することをお勧めします。
モデルの想定インスタンスのリストは、[DescribeModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeModel.html) API、SageMaker Python SDK、または SageMaker AI コンソールを使用してプログラムで表示できます。
**注記**
この機能が利用可能になるまで、SageMaker AI で作成したモデルの想定インスタンスを取得できません。
コンソールを使用してモデルの想定インスタンスを表示するには、以下の操作を行います。
1. [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/) で、SageMaker コンソールに移動します。
1. 左側のナビゲーションペインで **[推論]** を選択し、次に **[モデル]** を選択します。
1. モデルのリストから、目的のモデルを選択します。
モデルの詳細ページで、**[モデルをデプロイする想定インスタンス]** セクションに移動します。次のスクリーンショットは、このセクションを示しています。
![\[モデル詳細ページの想定インスタンスのリストのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inf-rec-prospective.png)
このセクションには、モデルデプロイのコスト、スループット、レイテンシーが最適化される想定インスタンスが、メモリサイズ、CPU と GPU の数、時間あたりのコストなどのインスタンスタイプごとの追加情報とともに表示されます。
サンプルペイロードをベンチマークしてモデルの推論の完全レコメンデーションジョブを実行する場合は、このページからデフォルトの推論レコメンデーションジョブを開始できます。コンソールからデフォルトジョブを開始するには、以下の操作を行います。
1. モデルの詳細ページの **[モデルをデプロイする想定インスタンス] セクション**で **[推論レコメンダージョブを実行]** を選択します。
1. 表示されるダイアログボックスの **[ペイロードのベンチマーク用 S3 バケット]** に、モデルのサンプルペイロードを保存した Amazon S3 の場所を入力します。
1. **[ペイロードコンテンツタイプ]** には、ペイロードデータの MIME タイプを入力します。
1. (オプション) **[SageMaker Neo を使用したモデルコンパイル]** セクションの **[データ入力設定]** にデータ形状をディクショナリ形式で入力します。
1. **[ジョブの実行]** を選択します。
Inference Recommender によってジョブが開始され、SageMaker AI コンソールの **[推論レコメンダー]** リストページにジョブとその結果が表示されます。
高度なジョブを実行してカスタムのロードテストを実行する場合や、ジョブに追加の設定とパラメータを設定する場合は、「[カスタムロードテストを実行する](inference-recommender-load-test.md)」を参照してください。
# 推論レコメンデーション
推論レコメンデーションジョブは、レコメンデーションインスタンスタイプまたはサーバーレスエンドポイントに対して一連のロードテストを実行します。推論レコメンデーションジョブでは、モデルバージョンの登録時に指定したサンプルデータを使用したロードテストに基づくパフォーマンスメトリクスを使用します。
**注記**
推論レコメンデーションジョブを作成する前に、[Amazon SageMaker Inference Recommender を使用するための前提条件](inference-recommender-prerequisites.md)が満たされていることを確認してください。
以下は、Amazon SageMaker Inference Recommender を使用して AWS SDK for Python (Boto3)、、Amazon SageMaker Studio Classic AWS CLI、および SageMaker AI コンソールを使用してモデルタイプに基づいて推論レコメンデーションを作成する方法を示しています。
**Topics**
+ [推論レコメンデーションを作成する](instance-recommendation-create.md)
+ [推論レコメンデーションジョブの結果を取得する](instance-recommendation-results.md)
# 推論レコメンデーションを作成する
AWS SDK for Python (Boto3) または を使用してプログラムで推論レコメンデーションを作成するか AWS CLI、Studio Classic または SageMaker AI コンソールを使用してインタラクティブに推論レコメンデーションを作成します。モデルをモデルレジストリに登録するときに推論レコメンデーションのジョブ名、IAM AWS ロール ARN、入力設定、モデルパッケージ ARN、または**前提条件**セクションでモデルを作成したときのモデル名と`ContainerConfig`ディクショナリを指定します。
------
#### [ AWS SDK for Python (Boto3) ]
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html) API を使用して推論レコメンデーションジョブを開始します。推論レコメンデーションジョブの `JobType` フィールドを `'Default'` に設定します。さらに、以下を指定します。
+ Inference Recommender がユーザーに代わってタスクを実行できるようにする IAM ロールの Amazon リソースネーム (ARN)。これを `RoleArn` フィールドで定義します。
+ モデルパッケージ ARN またはモデル名。Inference Recommender は、1 つのモデルパッケージ ARN またはモデル名を入力としてサポートします。次のいずれかを指定します。
+ モデルを SageMaker AI モデルレジストリに登録したときに作成したバージョン管理されたモデルパッケージの ARN。これを `InputConfig` フィールドの `ModelPackageVersionArn` で定義します。
+ 作成したモデルの名前。これを `InputConfig` フィールドの `ModelName` で定義します。モデル名で指定する必要がある必須フィールドを含む `ContainerConfig` ディクショナリも指定します。これを `InputConfig` フィールドの `ContainerConfig` で定義します。`ContainerConfig` では、オプションで `SupportedEndpointType` フィールドを `RealTime` または `Serverless` として指定することもできます。このフィールドを指定した場合は、Inference Recommender ではそのエンドポイントタイプについてのみ、レコメンデーションを返します。このフィールドを指定しない場合は、Inference Recommender では両方のエンドポイントタイプについて、レコメンデーションを返します。
+ `JobName` フィールドの Inference Recommender レコメンデーションジョブの名前。Inference Recommender ジョブ名は、 AWS リージョン内およびアカウント AWS 内で一意である必要があります。
AWS SDK for Python (Boto3) パッケージをインポートし、 クライアントクラスを使用して SageMaker AI クライアントオブジェクトを作成します。「**前提条件**」セクションの手順に従った場合、次のうちの 1 つだけを指定してください。
+ オプション 1: モデルパッケージ ARN を使用して推論レコメンデーションジョブを作成する場合は、モデルパッケージグループ ARN を `model_package_arn` という名前の変数に保存します。
+ オプション 2: モデル名と `ContainerConfig` を使用して推論レコメンデーションジョブを作成し、モデル名を `model_name` という名前の変数に保存して、`ContainerConfig` ディクショナリを `container_config` という名前の変数に格納します。
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide only one of model package ARN or model name, not both.
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn = ''
## Uncomment if you would like to create an inference recommendations job with a
## model name instead of a model package ARN, and comment out model_package_arn above
## Provide your model name
# model_name = ''
## Provide your container config
# container_config = ''
# Provide a unique job name for SageMaker Inference Recommender job
job_name = ''
# Inference Recommender job type. Set to Default to get an initial recommendation
job_type = 'Default'
# Provide an IAM Role that gives SageMaker Inference Recommender permission to
# access AWS services
role_arn = 'arn:aws:iam:::role/*'
sagemaker_client.create_inference_recommendations_job(
JobName = job_name,
JobType = job_type,
RoleArn = role_arn,
# Provide only one of model package ARN or model name, not both.
# If you would like to create an inference recommendations job with a model name,
# uncomment ModelName and ContainerConfig, and comment out ModelPackageVersionArn.
InputConfig = {
'ModelPackageVersionArn': model_package_arn
# 'ModelName': model_name,
# 'ContainerConfig': container_config
}
)
```
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html) に渡すことができるオプションの引数と必須の引数の完全なリストについては、[Amazon SageMaker API リファレンスガイド](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html)を参照してください。
------
#### [ AWS CLI ]
`create-inference-recommendations-job` API を使用して推論レコメンデーションジョブを開始します。推論レコメンデーションジョブの `job-type` フィールドを `'Default'` に設定します。さらに、以下を指定します。
+ Amazon SageMaker Inference Recommender がユーザーに代わってタスクを実行できるようにする IAM ロールの Amazon リソースネーム (ARN)。これを `role-arn` フィールドで定義します。
+ モデルパッケージ ARN またはモデル名。Inference Recommender は、1 つのモデルパッケージ ARN またはモデル名を入力としてサポートします。次のいずれかを指定します。
+ モデルをモデルレジストリに登録したときに作成したバージョン管理されたモデルパッケージの ARN。これを `input-config` フィールドの `ModelPackageVersionArn` で定義します。
+ 作成したモデルの名前。これを `input-config` フィールドの `ModelName` で定義します。モデル名で指定する必要がある必須フィールドを含む `ContainerConfig` ディクショナリも指定します。これを `input-config` フィールドの `ContainerConfig` で定義します。`ContainerConfig` では、オプションで `SupportedEndpointType` フィールドを `RealTime` または `Serverless` として指定することもできます。このフィールドを指定した場合は、Inference Recommender ではそのエンドポイントタイプについてのみ、レコメンデーションを返します。このフィールドを指定しない場合は、Inference Recommender では両方のエンドポイントタイプについて、レコメンデーションを返します。
+ `job-name` フィールドの Inference Recommender レコメンデーションジョブの名前。Inference Recommender ジョブ名は、 AWS リージョン内およびアカウント AWS 内で一意である必要があります。
モデルパッケージ ARN を使用して推論レコメンデーションジョブを作成するには、次の例を使用します。
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:\",
}"
```
モデル名と `ContainerConfig` を使用して推論レコメンデーションジョブを作成するには、次の例を使用します。この例では、`SupportedEndpointType` フィールドを使用して、リアルタイムの推論レコメンデーションのみを返すように指定しています。
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelName\": \"model-name\",
\"ContainerConfig\" : {
\"Domain\": \"COMPUTER_VISION\",
\"Framework\": \"PYTORCH\",
\"FrameworkVersion\": \"1.7.1\",
\"NearestModelName\": \"resnet18\",
\"PayloadConfig\":
{
\"SamplePayloadUrl\": \"s3://{bucket}/{payload_s3_key}\",
\"SupportedContentTypes\": [\"image/jpeg\"]
},
\"SupportedEndpointType\": \"RealTime\",
\"DataInputConfig\": \"[[1,3,256,256]]\",
\"Task\": \"IMAGE_CLASSIFICATION\",
},
}"
```
------
#### [ Amazon SageMaker Studio Classic ]
Studio Classic で推論レコメンデーションジョブを作成します。
1. Studio Classic アプリケーションで、ホームアイコン (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/studio/icons/house.png)) を選択します。
1. Studio Classic の左側のサイドバーで **[モデル]** を選択します。
1. ドロップダウンリストから **[モデルレジストリ]** を選択し、モデルレジストリに登録したモデルを表示します。
左側のパネルに、モデルグループのリストが表示されます。リストには、Studio Classic 以外で登録されたモデルを含む、アカウントのモデルレジストリに登録されているすべてのモデルグループが含まれます。
1. モデルグループの名前を選択します。モデルグループを選択すると、Studio Classic の右ペインに、**[バージョン]** や **[設定]** などの列見出しが表示されます。
モデルグループ内に 1 つ以上のモデルパッケージがある場合は、それらのモデルパッケージのリストが **[バージョン]** 列に表示されます。
1. **[Inference Recommender]** 列を選択します。
1. Inference Recommender に AWS サービスへのアクセス許可を付与する IAM ロールを選択します。これを行うには、ロールを作成し、`AmazonSageMakerFullAccess` IAM マネージドポリシーをアタッチします。または、Studio Classic にロールを作成させることもできます。
1. **[レコメンデーションの取得]** を選択します。
推論レコメンデーションには、最大 45 分かかることがあります。
**警告**
このタブを閉じないでください。このタブを閉じると、インスタンスのレコメンデーションジョブがキャンセルされます。
------
#### [ SageMaker AI console ]
次の手順を実行して、SageMaker AI コンソールからインスタンスレコメンデーションジョブを作成します。
1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) に移動します。
1. 左側のナビゲーションペインで、**[推論]** を選択し、次に **[推論レコメンダー]** を選択します。
1. **[推論レコメンダージョブ]** ページで **[ジョブを作成]** を選択します。
1. **[ステップ 1: モデル設定]** で、以下の操作を行います。
1. **[ジョブタイプ]** には、**[デフォルトのレコメンデーションジョブ]** を選択します。
1. SageMaker AI モデルレジストリに登録されているモデルを使用する場合は、**[モデルレジストリからモデルを選択]** トグルをオンにして、以下の操作を行います。
1. **[モデルグループ]** ドロップダウンリストから、モデルがある SageMaker AI モデルレジストリ内のモデルグループを選択します。
1. **[モデルバージョン]** ドロップダウンリストから、目的のバージョンのモデルを選択します。
1. SageMaker AI で作成したモデルを使用する場合は、**[モデルレジストリからモデルを選択]** トグルをオフにして、以下の操作を行います。
1. **[モデル名]** フィールドには、SageMaker AI モデルの名前を入力します。
1. **IAM ロール**ドロップダウンリストから、インスタンスレコメンデーションジョブを作成するために必要なアクセス許可を持つ既存の AWS IAM ロールを選択できます。または、既存のロールがない場合は、**[新しいロールの作成]** を選択してロール作成ポップアップを開くと、SageMaker AI によって作成した新しいロールに必要な権限が追加されます。
1. **[ペイロードをベンチマークするための S3 バケット]** には、サンプルペイロードアーカイブへの Amazon S3 パスを入力します。これには、Inference Recommender がさまざまなインスタンスタイプでモデルをベンチマークするために使用するサンプルペイロードファイルが含まれている必要があります。
1. **[ペイロードコンテンツタイプ]** には、サンプルペイロードデータの MIME タイプを入力します。
1. (オプション) **[モデルレジストリからモデルを選択]** トグルをオフにし、SageMaker AI モデルを指定した場合は、**[コンテナの設定]** で以下の操作を行います。
1. **[ドメイン]** ドロップダウンリストでは、コンピュータビジョン、自然言語処理、機械学習など、モデルの機械学習ドメインを選択します。
1. **[フレームワーク]** ドロップダウンリストでは、TensorFlow や XGBoost など、コンテナのフレームワークを選択します。
1. **[フレームワークバージョン]** には、コンテナイメージのフレームワークバージョンを入力します。
1. **[最も近いモデル名]** ドロップダウンリストでは、自分のモデルと最もよく一致する事前トレーニング済みのモデルを選択します。
1. **[タスク]** ドロップダウンリストでは、画像分類やリグレッションなど、モデルが実行する機械学習タスクを選択します。
1. (オプション) **[SageMaker Neo を使用したモデルコンパイル]** では、SageMaker Neo を使用してコンパイルしたモデルのレコメンデーションジョブを設定できます。**[データ入力設定]** には、モデルに適した入力データ形状を `{'input':[1,1024,1024,3]}` のような形式で入力します。
1. [**次へ**] を選択します。
1. **[ステップ 2: インスタンスと環境パラメータ]** では、以下の操作を行います。
1. (オプション) **[ベンチマーキング用のインスタンスを選択]** では、ベンチマークするインスタンスタイプを最大 8 個選択できます。いずれのインスタンスも選択しない場合、Inference Recommender はすべてのインスタンスタイプを考慮します。
1. [**次へ**] を選択します。
1. **[ステップ 3: ジョブパラメータ]** では、以下の操作を行います。
1. (オプション) **[ジョブ名]** フィールドに、インスタンスレコメンデーションジョブの名前を入力します。ジョブを作成すると、SageMaker AI によってこの名前の末尾にタイムスタンプが追加されます。
1. (オプション) **[ジョブの説明]** に、ジョブの説明を入力します。
1. (オプション) **暗号化キー**ドロップダウンリストで、名前で AWS KMS キーを選択するか、ARN を入力してデータを暗号化します。
1. (オプション) **[最大テスト時間]** には、各テストを実行する最大秒数を入力します。
1. (オプション) **[1 分あたりの最大呼び出し数]** には、推奨ジョブを停止するまでにエンドポイントが到達できる 1 分あたりの最大リクエスト数を入力します。この制限に達すると、SageMaker AI はジョブを終了します。
1. (オプション) **[P99 モデルレイテンシーのしきい値]** には、モデルレイテンシーのパーセンタイルをミリ秒単位で入力します。
1. [**次へ**] を選択します。
1. **[ステップ 4: ジョブを確認]** では、設定を確認して **[送信]** を選択します。
------
# 推論レコメンデーションジョブの結果を取得する
AWS SDK for Python (Boto3)、、Studio Classic AWS CLI、または SageMaker AI コンソールを使用して、推論レコメンデーションジョブの結果をプログラムで収集します。
------
#### [ AWS SDK for Python (Boto3) ]
推論レコメンデーションが完了したら、`DescribeInferenceRecommendationsJob` を使用して、ジョブの詳細とレコメンデーションを取得します。推論レコメンデーションジョブを作成したときに使用したジョブ名を指定します。
```
job_name=''
response = sagemaker_client.describe_inference_recommendations_job(
JobName=job_name)
```
レスポンスオブジェクトを出力します。前のコードサンプルで、レスポンスを `response` という名前の変数に保存しました。
```
print(response['Status'])
```
ここでは、次の例のような JSON レスポンスが返されます。この例はリアルタイム推論に推奨されるインスタンスタイプを示していることに注意してください (サーバーレス推論レコメンデーションを示す例については、この後の例を参照してください)。
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Default',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 20, 4, 57, 627000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 20, 25, 1, 997000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 0
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.20399999618530273,
'CostPerInference': 5.246913588052848e-06,
'MaximumInvocations': 648,
'ModelLatency': 263596
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5.xlarge',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 2.92620870823157e-06,
'MaximumInvocations': 655,
'ModelLatency': 826019
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 3.3625731248321244e-06,
'MaximumInvocations': 570,
'ModelLatency': 1085446
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.m5.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1685',
'date': 'Tue, 26 Oct 2021 20:31:10 GMT'
},
'RetryAttempts': 0
}
}
```
最初の数行には、推論レコメンデーションジョブ自体に関する情報が示されています。これには、ジョブ名、ロール ARN、作成時間と削除時間が含まれます。
`InferenceRecommendations` ディクショナリには、Inference Recommender 推論レコメンデーションのリストが含まれています。
`EndpointConfiguration` ネストされたディクショナリには、レコメンデーションジョブ中に使用されたエンドポイントとバリアント名 (デプロイされた AWS 機械学習モデル`InstanceType`) とともに、インスタンスタイプ () レコメンデーションが含まれています。Amazon CloudWatch Events でのモニタリングには、エンドポイントとバリアント名を使用できます。詳細については「[Amazon CloudWatch における Amazon SageMaker AI メトリクス](monitoring-cloudwatch.md)」を参照してください。
`Metrics` のネストされたディクショナリには、リアルタイムエンドポイントの 1 時間あたりの推定コスト (`CostPerHour`) (USD)、リアルタイムエンドポイントの推論あたりの推定コスト (`CostPerInference`) (USD)、エンドポイントに送信される `InvokeEndpoint` リクエストの 1 分あたりの最大数 (`MaxInvocations`)、モデルが SageMaker AI に応答するのにかかった時間間隔 (マイクロ秒単位) である、モデルのレイテンシー (`ModelLatency`) に関する情報が含まれています。モデルのレイテンシーには、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかるローカル通信時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。
以下の例は、サーバーレス推論レコメンデーションを返すように設定された推論レコメンデーションジョブのレスポンスの `InferenceRecommendations` 部を示しています。
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
サーバーレス推論のレコメンデーションは、リアルタイム推論の結果と同様に解釈できます。ただし、`ServerlessConfig` は例外で、`MemorySizeInMB` が指定され、`MaxConcurrency = 1` のときにサーバーレスエンドポイントに対して返されるメトリクスを示します。エンドポイントで可能なスループットを向上させるには、`MaxConcurrency` の値を直線的に増加します。たとえば、推論レコメンデーションによって `MaxInvocations` が `1000` として示されている場合、`MaxConcurrency` を `2` に増加すると、2000 `MaxInvocations` がサポートされます。これは特定の時点までしか当てはまらず、モデルやコードによって異なる可能性があることに注意してください。サーバーレスレコメンデーションではメトリクス `ModelSetupTime` も測定され、これにより、サーバーレスエンドポイントでコンピューターリソースを起動するのにかかる時間 (マイクロ秒単位) が測定されます。サーバーレスエンドポイントの設定について詳しくは、[サーバーレス推論のドキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html)を参照してください。
------
#### [ AWS CLI ]
推論レコメンデーションが完了したら、`describe-inference-recommendations-job` を使用して、ジョブの詳細とレコメンデーションインスタンスタイプを取得します。推論レコメンデーションジョブを作成したときに使用したジョブ名を指定します。
```
aws sagemaker describe-inference-recommendations-job\
--job-name \
--region
```
同様の JSON レスポンスは、次の例のようになります。この例はリアルタイム推論に推奨されるインスタンスタイプを示していることに注意してください (サーバーレス推論レコメンデーションを示す例については、この後の例を参照してください)。
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Default',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 20, 4, 57, 627000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 20, 25, 1, 997000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 0
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.20399999618530273,
'CostPerInference': 5.246913588052848e-06,
'MaximumInvocations': 648,
'ModelLatency': 263596
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5.xlarge',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 2.92620870823157e-06,
'MaximumInvocations': 655,
'ModelLatency': 826019
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
},
{
'Metrics': {
'CostPerHour': 0.11500000208616257,
'CostPerInference': 3.3625731248321244e-06,
'MaximumInvocations': 570,
'ModelLatency': 1085446
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.m5.large',
'InitialInstanceCount': 1
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1685',
'date': 'Tue, 26 Oct 2021 20:31:10 GMT'
},
'RetryAttempts': 0
}
}
```
最初の数行には、推論レコメンデーションジョブ自体に関する情報が示されています。これには、ジョブ名、ロール ARN、作成、削除時間が含まれます。
`InferenceRecommendations` ディクショナリには、Inference Recommender 推論レコメンデーションのリストが含まれています。
`EndpointConfiguration` ネストされたディクショナリには、レコメンデーションジョブ中に使用されるエンドポイントとバリアント名 (デプロイされた AWS 機械学習モデル`InstanceType`) とともに、インスタンスタイプ () レコメンデーションが含まれています。Amazon CloudWatch Events でのモニタリングには、エンドポイントとバリアント名を使用できます。詳細については「[Amazon CloudWatch における Amazon SageMaker AI メトリクス](monitoring-cloudwatch.md)」を参照してください。
`Metrics` のネストされたディクショナリには、リアルタイムエンドポイントの 1 時間あたりの推定コスト (`CostPerHour`) (USD)、リアルタイムエンドポイントの推論あたりの推定コスト (`CostPerInference`) (USD)、エンドポイントに送信される `InvokeEndpoint` リクエストの 1 分あたりの最大数 (`MaxInvocations`)、モデルが SageMaker AI に応答するのにかかった時間間隔 (ミリ秒単位) である、モデルのレイテンシー (`ModelLatency`) に関する情報が含まれています。モデルのレイテンシーには、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかるローカル通信時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。
以下の例は、サーバーレス推論レコメンデーションを返すように設定された推論レコメンデーションジョブのレスポンスの `InferenceRecommendations` 部を示しています。
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
サーバーレス推論のレコメンデーションは、リアルタイム推論の結果と同様に解釈できます。ただし、`ServerlessConfig` は例外で、`MemorySizeInMB` が指定され、`MaxConcurrency = 1` のときにサーバーレスエンドポイントに対して返されるメトリクスを示します。エンドポイントで可能なスループットを向上させるには、`MaxConcurrency` の値を直線的に増加します。たとえば、推論レコメンデーションによって `MaxInvocations` が `1000` として示されている場合、`MaxConcurrency` を `2` に増加すると、2000 `MaxInvocations` がサポートされます。これは特定の時点までしか当てはまらず、モデルやコードによって異なる可能性があることに注意してください。サーバーレスレコメンデーションではメトリクス `ModelSetupTime` も測定され、これにより、サーバーレスエンドポイントでコンピューターリソースを起動するのにかかる時間 (マイクロ秒単位) が測定されます。サーバーレスエンドポイントの設定について詳しくは、[サーバーレス推論のドキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html)を参照してください。
------
#### [ Amazon SageMaker Studio Classic ]
推論レコメンデーションは、Studio Classic 内の新しい **[推論レコメンデーション]** タブに表示されます。結果が表示されるまでに最大 45 分かかることがあります。このタブには、**[結果]** と **[詳細]** 列見出しが含まれています。
**[詳細]** 列には、推論レコメンデーションの名前や、ジョブの作成日時 ([**作成日時**]) といった、推論レコメンデーションジョブに関する情報が表示されます。また、1 分あたりに発生した最大呼び出し数や、使用された Amazon リソースネーム (ARN) といった、**[設定]** 情報も表示されます。
**[結果]** 列には、**[デプロイの目標]** と **[SageMaker AI レコメンデーション]** ウィンドウが表示され、デプロイの重要度に基づいて結果が表示される順序を調整できます。ユースケースの **[Cost]** (コスト)、**[Latency]** (レイテンシー)、**[Throughput]** (スループット) の重要レベルを指定できる 3 つのドロップダウンメニューがあります。目標（コスト、レイテンシー、スループット）ごとに、**最小重要度**、**低重要度**、**中重要度**、**高重要度**、または**最高重要度**の重要度のレベルを設定できます。
各目標の重要度の選択に基づいて、Inference Recommender はその最上位レコメンデーションを、パネル右側の **[SageMaker recommendation]** (SageMaker レコメンデーション)フィールドに、時間あたりの推定コストと推論リクエストとともに表示します。また、予想されるモデルのレイテンシー、最大呼び出し数、インスタンス数に関する情報も表示されます。サーバーレスレコメンデーションについては、最大同時実行数とエンドポイントのメモリサイズの理想的な値をご覧ください。
表示される上位のレコメンデーションに加えて、Inference Recommender がテストしたすべてのインスタンスについての同じ情報が**[All runs]** (すべての実行) セクションに表示されます。
------
#### [ SageMaker AI console ]
次の手順を実行して、SageMaker AI コンソールでインスタンスレコメンデーションジョブを表示します。
1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) に移動します。
1. 左側のナビゲーションペインで、**[推論]** を選択し、次に **[推論レコメンダー]** を選択します。
1. **[推論レコメンダージョブ]** ページで、推論レコメンデーションジョブの名前を選択します。
ジョブの詳細ページでは、以下のスクリーンショットに示すように、SageMaker AI がモデルに推奨するインスタンスタイプである **[推論のレコメンデーション]** を表示できます。
![\[SageMaker AI コンソールのジョブ詳細ページにある推論レコメンデーションリストのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inf-rec-instant-recs.png)
このセクションでは、**[モデルレイテンシー]**、**[1 時間あたりのコスト]**、**[推論あたりのコスト]**、**[1 分あたりの呼び出し]** などのさまざまな要因でインスタンスタイプを比較できます。
このページでは、ジョブに指定した設定も表示できます。**[モニター]** セクションでは、インスタンスタイプごとに記録された Amazon CloudWatch メトリクスを表示できます。これらのメトリクスの解釈について詳しくは、「[結果の解釈](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-interpret-results.html)」を参照してください。
------
レコメンデーションジョブの結果について詳しくは、「[レコメンデーション結果](inference-recommender-interpret-results.md)」を参照してください。
# 既存のエンドポイントの推論レコメンデーションを取得する
推論レコメンデーションジョブは、レコメンデーションインスタンスタイプおよび既存のエンドポイントに対して一連のロードテストを実行します。推論レコメンデーションジョブでは、モデルバージョンの登録時に指定したサンプルデータを使用したロードテストに基づくパフォーマンスメトリクスを使用します。
既存の SageMaker AI Inference エンドポイントをベンチマークして推論レコメンデーションを取得し、エンドポイントのパフォーマンスを向上させるのに役立てることができます。既存の SageMaker AI Inference エンドポイントのレコメンデーションを取得する手順は、エンドポイントを作成せずに[推論レコメンデーションを取得する](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-instance-recommendation.html)手順と似ています。既存のエンドポイントをベンチマークする際に注意すべき機能の除外事項がいくつかあります。
+ 既存のエンドポイントは、Inference Recommender ジョブごとに 1 つしか使用できません。
+ エンドポイントで設定できるバリアントは 1 つだけです。
+ 自動スケーリングを有効にするエンドポイントは使用できません。
+ この機能は[リアルタイム推論](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html)でのみサポートされています。
+ この機能は[リアルタイムマルチモデルエンドポイント](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html)をサポートしていません。
**警告**
Inference Recommender ジョブは、ライブトラフィックを処理するプロダクションエンドポイントでは実行しないことを強くお勧めします。ベンチマーク中の合成負荷はプロダクションエンドポイントに影響を及ぼし、スロットリングを引き起こしたり、ベンチマーク結果が不正確になったりする可能性があります。比較目的では、非本番環境または開発者向けエンドポイントを使用することをおすすめします。
以下のセクションでは、Amazon SageMaker Inference Recommender を使用して、 AWS SDK for Python (Boto3) と を使用してモデルタイプに基づいて既存のエンドポイントの推論レコメンデーションを作成する方法を示します AWS CLI。
**注記**
推論レコメンデーションジョブを作成する前に、[Amazon SageMaker Inference Recommender を使用するための前提条件](inference-recommender-prerequisites.md)が満たされていることを確認してください。
## 前提条件
SageMaker AI Inference エンドポイントをまだ作成していない場合は、エンドポイント作成せずに[推論レコメンデーションを取得](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-instance-recommendation.html)するか、「[エンドポイントを作成し、モデルをデプロイする](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html)」の手順に従ってリアルタイム推論エンドポイントを作成します。
## 既存のエンドポイントの推論レコメンデーションジョブを作成する
AWS SDK for Python (Boto3)または を使用して、推論レコメンデーションをプログラムで作成します AWS CLI。推論レコメンデーションのジョブ名、既存の SageMaker AI 推論エンドポイントの名前、IAM AWS ロール ARN、入力設定、およびモデルをモデルレジストリに登録したときのモデルパッケージ ARN を指定します。
------
#### [ AWS SDK for Python (Boto3) ]
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html) API を使用して推論レコメンデーションジョブを取得します。推論レコメンデーションジョブの `JobType` フィールドを `'Default'` に設定します。さらに、以下を指定します。
+ `JobName` フィールドに Inference Recommender レコメンデーションジョブの名前を入力します。Inference Recommender ジョブ名は、 AWS リージョン内およびアカウント AWS 内で一意である必要があります。
+ Inference Recommender がユーザーに代わってタスクを実行できるようにする IAM ロールの Amazon リソースネーム (ARN)。これを `RoleArn` フィールドで定義します。
+ モデルをモデルレジストリに登録したときに作成したバージョン管理されたモデルパッケージの ARN。これを `InputConfig` フィールドの `ModelPackageVersionArn` で定義します。
+ `InputConfig` フィールドに Inference Recommender の `Endpoints` をベンチマークする既存の SageMaker AI 推論エンドポイントの名前を指定します。
AWS SDK for Python (Boto3) パッケージをインポートし、 クライアントクラスを使用して SageMaker AI クライアントオブジェクトを作成します。「**前提条件**」セクションのステップに従った場合、モデルパッケージグループ ARN は、`model_package_arn` という名前の変数に格納されています。
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn = ''
# Provide a unique job name for SageMaker Inference Recommender job
job_name = ''
# Inference Recommender job type. Set to Default to get an initial recommendation
job_type = 'Default'
# Provide an IAM Role that gives SageMaker Inference Recommender permission to
# access AWS services
role_arn = ':role/*>'
# Provide endpoint name for your endpoint that want to benchmark in Inference Recommender
endpoint_name = ''
sagemaker_client.create_inference_recommendations_job(
JobName = job_name,
JobType = job_type,
RoleArn = role_arn,
InputConfig = {
'ModelPackageVersionArn': model_package_arn,
'Endpoints': [{'EndpointName': endpoint_name}]
}
)
```
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateInferenceRecommendationsJob.html) に渡すことができるオプションの引数と必須の引数の完全なリストについては、[Amazon SageMaker API リファレンスガイド](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html)を参照してください。
------
#### [ AWS CLI ]
`create-inference-recommendations-job` API を使用してインスタンスエンドポイントのレコメンデーションを取得します。`job-type` フィールドを、インスタンスエンドポイントのレコメンデーションジョブの `'Default'` に設定します。さらに、以下を指定します。
+ `job-name` フィールドに Inference Recommender レコメンデーションジョブの名前を入力します。Inference Recommender ジョブ名は、 AWS リージョン内およびアカウント AWS 内で一意である必要があります。
+ Amazon SageMaker Inference Recommender がユーザーに代わってタスクを実行できるようにする IAM ロールの Amazon リソースネーム (ARN)。これを `role-arn` フィールドで定義します。
+ モデルをモデルレジストリに登録したときに作成したバージョン管理されたモデルパッケージの ARN。これを `input-config` フィールドの `ModelPackageVersionArn` で定義します。
+ `input-config` フィールドに Inference Recommender の `Endpoints` をベンチマークする既存の SageMaker AI 推論エンドポイントの名前を指定します。
```
aws sagemaker create-inference-recommendations-job
--region \
--job-name \
--job-type Default\
--role-arn arn:aws:iam::\
--input-config "{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:\",
\"Endpoints\": [{\"EndpointName\": }]
}"
```
------
## 推論レコメンデーションジョブの結果を取得する
推論レコメンデーションジョブの結果は、標準的な推論レコメンデーションジョブと同じ手順でプログラムを使用して収集できます。詳細については、「[推論レコメンデーションジョブの結果を取得する](instance-recommendation-results.md)」を参照してください。
既存のエンドポイントの推論レコメンデーションジョブの結果を取得すると、次のような JSON レスポンスが返されるはずです。
```
{
"JobName": "job-name",
"JobType": "Default",
"JobArn": "arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id",
"RoleArn": "iam-role-arn",
"Status": "COMPLETED",
"CreationTime": 1664922919.2,
"LastModifiedTime": 1664924208.291,
"InputConfig": {
"ModelPackageVersionArn": "arn:aws:sagemaker:region:account-id:model-package/resource-id",
"Endpoints": [
{
"EndpointName": "endpoint-name"
}
]
},
"InferenceRecommendations": [
{
"Metrics": {
"CostPerHour": 0.7360000014305115,
"CostPerInference": 7.456940238625975e-06,
"MaxInvocations": 1645,
"ModelLatency": 171
},
"EndpointConfiguration": {
"EndpointName": "sm-endpoint-name",
"VariantName": "variant-name",
"InstanceType": "ml.g4dn.xlarge",
"InitialInstanceCount": 1
},
"ModelConfiguration": {
"EnvironmentParameters": [
{
"Key": "TS_DEFAULT_WORKERS_PER_MODEL",
"ValueType": "string",
"Value": "4"
}
]
}
}
],
"EndpointPerformances": [
{
"Metrics": {
"MaxInvocations": 184,
"ModelLatency": 1312
},
"EndpointConfiguration": {
"EndpointName": "endpoint-name"
}
}
]
}
```
最初の数行には、推論レコメンデーションジョブ自体に関する情報が示されています。これには、ジョブ名、ロール ARN、作成時間と最新の変更時間が含まれます。
`InferenceRecommendations` ディクショナリには、Inference Recommender 推論レコメンデーションのリストが含まれています。
`EndpointConfiguration` ネストされたディクショナリには、レコメンデーションジョブ中に使用されたエンドポイントとバリアント名 (デプロイされた AWS 機械学習モデル`InstanceType`) とともに、インスタンスタイプ () レコメンデーションが含まれています。
`Metrics` のネストされたディクショナリには、リアルタイムエンドポイントの 1 時間あたりの推定コスト (`CostPerHour`) (USD)、リアルタイムエンドポイントの推論あたりの推定コスト (`CostPerInference`) (USD)、エンドポイントに送信される `InvokeEndpoint` リクエストの 1 分あたりの最大数 (`MaxInvocations`)、モデルが SageMaker AI に応答するのにかかった時間間隔 (ミリ秒単位) である、モデルのレイテンシー (`ModelLatency`) に関する情報が含まれています。モデルのレイテンシーには、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかるローカル通信時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。
`EndpointPerformances` のネストされたディクショナリには、レコメンデーションジョブが実行された既存のエンドポイントの名前 (`EndpointName`) とエンドポイントのパフォーマンスメトリクス (`MaxInvocations` と `ModelLatency`) が含まれています。
# 推論レコメンデーションを停止する
ジョブを誤って開始した場合や、ジョブを実行する必要がなくなった場合は、現在実行中のジョブを停止できます。`StopInferenceRecommendationsJob` API または Studio Classic を使用して、Inference Recommender の推論レコメンデーションジョブをプログラムで停止します。
------
#### [ AWS SDK for Python (Boto3) ]
次の `JobName` フィールドに推論レコメンデーションジョブの名前を指定します。
```
sagemaker_client.stop_inference_recommendations_job(
JobName=''
)
```
------
#### [ AWS CLI ]
`job-name` フラグの推論レコメンデーションジョブのジョブ名を指定します。
```
aws sagemaker stop-inference-recommendations-job --job-name
```
------
#### [ Amazon SageMaker Studio Classic ]
インスタンスレコメンデーションを開始したタブを閉じて、Inference Recommender の推論レコメンデーションを停止します。
------
#### [ SageMaker AI console ]
SageMaker AI コンソールからインスタンスレコメンデーションジョブを停止するには、以下の操作を行います。
1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) に移動します。
1. 左側のナビゲーションペインで、**[推論]** を選択し、次に **[推論レコメンダー]** を選択します。
1. **[推論レコメンダージョブ]** ページで、インスタンスレコメンデーションジョブを選択します。
1. **[ジョブを停止]** を選択します。
1. ポップアップ表示されるダイアログボックスで、**[確認]** を選択します。
ジョブを停止すると、ジョブの **[ステータス]** が **[停止中]** に変わります。
------
# Neo でコンパイル済みのレコメンデーション
Inference Recommender では、Neo を使用してモデルをコンパイルし、コンパイルしたモデルのエンドポイントのレコメンデーションを取得できます。[SageMaker Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) は、ターゲットハードウェアプラットフォーム (つまり、特定のインスタンスタイプまたは環境) に合わせてモデルを最適化できるサービスです。Neo でモデルを最適化すると、ホストモデルのパフォーマンスが向上する場合があります。
NEO がサポートするフレームワークとコンテナの場合、Inference Recommender により NEO 最適化レコメンデーションが自動的に提案されます。Neo コンパイルを利用するには、入力が次の前提条件を満たす必要があります。
+ SageMaker AI が所有する [DLC](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) または XGBoost コンテナを使用している。
+ Neo がサポートするフレームワークバージョンを使用している。Neo がサポートするフレームワークバージョンについては、SageMaker Neo ドキュメントの「[クラウドインスタンス](neo-supported-cloud.md#neo-supported-cloud-instances)」を参照してください。
+ Neo では、モデルに適した入力データ形状を指定する必要がある。このデータ形状は、モデルパッケージの作成時に `[InferenceSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModelPackage.html#sagemaker-CreateModelPackage-request-InferenceSpecification)` で `[DataInputConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelInput.html#sagemaker-Type-ModelInput-DataInputConfig)` として指定できます。各フレームワークに適したデータ形状については、SageMaker Neo ドキュメントの「[コンパイルに向けてモデルを準備する](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html)」を参照してください。
次の例は、`InferenceSpecification` で `DataInputConfig` フィールドを指定する方法を示しています。ここで、`data_input_configuration` はディクショナリ形式のデータ形状を含む変数 (例: `{'input':[1,1024,1024,3]}`) です。
```
"InferenceSpecification": {
"Containers": [
{
"Image": dlc_uri,
"Framework": framework.upper(),
"FrameworkVersion": framework_version,
"NearestModelName": model_name,
"ModelInput": {"DataInputConfig": data_input_configuration},
}
],
"SupportedContentTypes": input_mime_types, # required, must be non-null
"SupportedResponseMIMETypes": [],
"SupportedRealtimeInferenceInstanceTypes": supported_realtime_inference_types, # optional
}
```
リクエストでこれらの条件が満たされると、Inference Recommender によってモデルのコンパイル済みバージョンとコンパイルされていないバージョンの両方に対してシナリオが実行され、複数のレコメンデーションの組み合わせを選択できるようになります。同じ推論レコメンデーションのコンパイル済みバージョンとコンパイルされていないバージョンの構成を比較して、ユースケースに最適なバージョンを特定できます。レコメンデーションは、推論あたりのコストによってランク付けされています。
Neo コンパイルのレコメンデーションを取得するには、入力が上記の要件を満たしていることを確認するだけで、追加の設定を行う必要はありません。入力が要件を満たしている場合、Inference Recommender はモデルに対して Neo コンパイルを自動的に実行し、Neo のレコメンデーションを含むレスポンスを受け取ります。
Neo のコンパイル中にエラーが発生した場合は、「[Neo のコンパイルエラーをトラブルシューティングする](neo-troubleshooting-compilation.md)」を参照してください。
以下の表は、コンパイル済みモデルのレコメンデーションを含む Inference Recommender ジョブから返される可能性のあるレスポンスの例です。`InferenceSpecificationName` フィールドが `None` の場合、レコメンデーションはコンパイルされていないモデルです。**InferenceSpecificationName** フィールドの値が `neo-00011122-2333-4445-5566-677788899900` の場合、最後の行は Neo でコンパイルされたモデル用です。フィールドの値は、モデルのコンパイルと最適化に使用される Neo ジョブの名前です。
| EndpointName | InstanceType | InitialInstanceCount | EnvironmentParameters | CostPerHour | CostPerInference | MaxInvocations | ModelLatency | InferenceSpecificationName |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| sm-epc-example-000111222 | ml.c5.9xlarge | 1 | [] | 1.836 | 9.15E-07 | 33456 | 7 | なし |
| sm-epc-example-111222333 | ml.c5.2xlarge | 1 | [] | 0.408 | 2.11E-07 | 32211 | 21 | なし |
| sm-epc-example-222333444 | ml.c5.xlarge | 1 | [] | 0.204 | 1.86E-07 | 18276 | 92 | なし |
| sm-epc-example-333444555 | ml.c5.xlarge | 1 | [] | 0.204 | 1.60E-07 | 21286 | 42 | neo-00011122-2333-4445-5566-677788899900 |
## はじめに
NEO 最適化レコメンデーションを含む Inference Recommender ジョブを作成する一般的な手順は次のとおりです。
+ コンパイルに向けて機械学習モデルを準備します。詳細については、Neo ドキュメントの「[コンパイルに向けてモデルを準備する](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-compilation-preparing-model.html)」を参照してください。
+ モデルをモデルアーカイブ (`.tar.gz` ファイル) にパッケージ化します。
+ サンプルペイロードアーカイブを作成します。
+ モデルを SageMaker モデルレジストリに登録します。
+ Inference Recommender を作成します。
+ Inference Recommender ジョブの結果を表示し、構成を選択します。
+ コンパイルに失敗した場合は、デバッグします。詳細については、「[Neo のコンパイルエラーをトラブルシューティングする](https://docs.aws.amazon.com/sagemaker/latest/dg/neo-troubleshooting-compilation.html)」を参照してください。
前述のワークフローと、XGBoost を使用して NEO 最適化レコメンデーションを取得する方法を示す例については、以下の[サンプルノートブック](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/xgboost/xgboost-inference-recommender.ipynb)を参照してください。TensorFlow を使用して NEO 最適化レコメンデーションを取得する方法を示す例については、以下の[サンプルノートブック](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/inference-recommender.ipynb)を参照してください。
# レコメンデーション結果
各 Inference Recommender ジョブの結果には `InstanceType`、`InitialInstanceCount`、`EnvironmentParameters` が含まれます。これらは、コンテナのレイテンシーとスループットを改善するためにコンテナに合わせて調整された環境変数パラメータです。結果には、`MaxInvocations`、`ModelLatency`、`CostPerHour`、`CostPerInference`、`CpuUtilization`、`MemoryUtilization` などのパフォーマンスとコストのメトリクスも含まれます。
以下の表では、これらのメトリクスについて説明します。これらのメトリクスは、ユースケースに最適なエンドポイント構成の検索対象を絞り込むのに役立ちます。たとえば、スループットを重視した全体的な価格性能が動機である場合は、`CostPerInference` に注目する必要があります。
| メトリクス | 説明 | ユースケース |
| --- | --- | --- |
| `ModelLatency` | SageMaker AI から見た、モデルが応答するのにかかる時間間隔。この間隔には、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかるローカル通信時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。 単位: ミリ秒 | 広告配信や医療診断など、レイテンシーの影響を受けやすいワークロード |
| `MaximumInvocations` | モデルエンドポイントに 1 分間に送信される最大 `InvokeEndpoint` リクエスト数。 単位: なし | ビデオ処理やバッチ推論など、スループットを重視するワークロード |
| `CostPerHour` | リアルタイムエンドポイントの 1 時間あたりの推定コスト。 単位: 米ドル | レイテンシーの期限のないコストの影響を受けやすいワークロード |
| `CostPerInference` | リアルタイムエンドポイントの推論呼び出しあたりの推定コスト。 単位: 米ドル | スループットを重視して、全体的なコストパフォーマンスを最大化する |
| `CpuUtilization` | エンドポイントインスタンスの 1 分あたりの最大呼び出し数における予想 CPU 使用率。 単位: パーセント | インスタンスのコア CPU 使用率を可視化することで、ベンチマーク中のインスタンスの状態を把握できます。 |
| `MemoryUtilization` | エンドポイントインスタンスの 1 分あたりの最大呼び出し数における予想メモリ使用率。 単位: パーセント | インスタンスのコアメモリ使用率を可視化することで、ベンチマーク中のインスタンスの状態を把握できます。 |
場合によっては、`CPUUtilization` など、他の [SageMaker AI エンドポイント呼び出しメトリクス](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation)を調べることもできます。すべての Inference Recommender ジョブの結果には、ロードテスト中にスピンアップされたエンドポイントの名前が含まれます。CloudWatch を使用すると、これらのエンドポイントのログを削除した後でも確認できます。
以下の画像は、推奨結果から単一のエンドポイントについて確認できる CloudWatch メトリクスとグラフの例です。この推奨結果はデフォルトジョブのものです。推奨結果のスカラー値を解釈する基準は、呼び出しグラフが最初に横ばいになり始めた時点です。たとえば、報告された `ModelLatency` 値は、`03:00:31` あたりに横ばいになり始めています。
![\[CloudWatch メトリクスのチャート。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference-recommender-cw-metrics.png)
上記のグラフで使用されている CloudWatch メトリクスの詳細については、「[SageMaker AI Endpoint Invocation metrics](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-endpoint-invocation)」を参照してください。
`/aws/sagemaker/InferenceRecommendationsJobs` 名前空間には Inference Recommender によって発行された `ClientInvocations` や `NumberOfUsers` のようなパフォーマンスメトリクスも表示されます。Inference Recommender によって発行されたメトリクスと説明の完全なリストについては、「[SageMaker Inference Recommender ジョブメトリクス](monitoring-cloudwatch.md#cloudwatch-metrics-inference-recommender)」を参照してください。
AWS SDK for Python (Boto3) を使用してエンドポイントの [ CloudWatch メトリクスを調べる方法の例については、amazon-sagemaker-examples Github リポジトリの Amazon SageMaker Inference Recommender -](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-inference-recommender/tensorflow-cloudwatch/tf-cloudwatch-inference-recommender.ipynb) CloudWatch Metrics Jupyter Notebook を参照してください。 [amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples)
# 自動スケーリングポリシーレコメンデーションを取得する
Amazon SageMaker Inference Recommender を使用すると、予想されるトラフィックパターンに基づいて、SageMaker AI エンドポイントの自動スケーリングポリシーのレコメンデーションを取得できます。推論レコメンデーションジョブをすでに完了している場合は、ジョブの詳細を指定して、エンドポイントに適用できる自動スケーリングポリシーのレコメンデーションを取得できます。
Inference Recommender は、各メトリクスの異なる値をベンチマークして、エンドポイントに最適な自動スケーリング設定を決定します。自動スケーリングレコメンデーションによって、推論レコメンデーションジョブで定義された各メトリクスの推奨オートスケーリングポリシーが返されます。このポリシーを保存し、[PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html) API を使用してエンドポイントに適用できます。
開始するには、以下の前提条件を参照してください。
## 前提条件
開始する前に、成功した推論レコメンデーションジョブを完了している必要があります。次のセクションでは、推論レコメンデーション ID または推論レコメンデーションジョブ中にベンチマークされた SageMaker AI エンドポイントの名前を指定できます。
レコメンデーションジョブ ID またはエンドポイント名を取得するには、SageMaker AI コンソールで推論レコメンデーションジョブの詳細を表示するか、[DescribeInferenceRecommendationsJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeInferenceRecommendationsJob.html) API によって返される `RecommendationId` または `EndpointName` フィールドを使用します。
## 自動スケーリング設定レコメンデーションを作成する
自動スケーリングレコメンデーションポリシーを作成するには、 AWS SDK for Python (Boto3)を使用します。
次の例は、[GetScalingConfigurationRecommendation](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_GetScalingConfigurationRecommendation.html) API のフィールドを示しています。API を呼び出す際は、以下のフィールドを使用します。
+ `InferenceRecommendationsJobName` — 推論レコメンデーションジョブの名前を入力します。
+ `RecommendationId` — レコメンデーションジョブの推論レコメンデーションの ID を入力します。`EndpointName` フィールドを指定した場合、これはオプションです。
+ `EndpointName` — 推論レコメンデーションジョブ中にベンチマークされたエンドポイントの名前を入力します。`RecommendationId` フィールドを指定した場合、これはオプションです。
+ `TargetCpuUtilizationPerCore` — (オプション) 自動スケーリング前にエンドポイント上のインスタンスが使用する使用率のパーセント値を入力します。このフィールドを指定しない場合のデフォルト値は 50%です。
+ `ScalingPolicyObjective` — (オプション) 予想されるトラフィックパターンを指定するオブジェクト。
+ `MinInvocationsPerMinute` — (オプション) エンドポイントへの 1 分あたりの予想リクエストの最小数。
+ `MaxInvocationsPerMinute` — (オプション) エンドポイントへの 1 分あたりの予想リクエストの最大数。
```
{
"InferenceRecommendationsJobName": "string", // Required
"RecommendationId": "string", // Optional, provide one of RecommendationId or EndpointName
"EndpointName": "string", // Optional, provide one of RecommendationId or EndpointName
"TargetCpuUtilizationPerCore": number, // Optional
"ScalingPolicyObjective": { // Optional
"MinInvocationsPerMinute": number,
"MaxInvocationsPerMinute": number
}
}
```
リクエストの送信後、各メトリクスに定義された自動スケーリングポリシーを含むレスポンスを受信します。レスポンスの解釈の詳細については、以下のセクションを参照してください。
## 自動スケーリング設定の推奨結果を確認する
次の例は、[GetScalingConfigurationRecommendation](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_GetScalingConfigurationRecommendation.html) API からのレスポンスを示しています。
```
{
"InferenceRecommendationsJobName": "string",
"RecommendationId": "string", // One of RecommendationId or EndpointName is shown
"EndpointName": "string",
"TargetUtilizationPercentage": Integer,
"ScalingPolicyObjective": {
"MinInvocationsPerMinute": Integer,
"MaxInvocationsPerMinute": Integer
},
"Metric": {
"ModelLatency": Integer,
"InvocationsPerInstance": Integer
},
"DynamicScalingConfiguration": {
"MinCapacity": number,
"MaxCapacity": number,
"ScaleInCooldown": number,
"ScaleOutCooldown": number,
"ScalingPolicies": [
{
"TargetTracking": {
"MetricSpecification": {
"Predefined" {
"PredefinedMetricType": "string"
},
"Customized": {
"MetricName": "string",
"Namespace": "string",
"Statistic": "string"
}
},
"TargetValue": Double
}
}
]
}
}
```
`InferenceRecommendationsJobName`、`RecommendationID` または `EndpointName`、`TargetCpuUtilizationPerCore`、および `ScalingPolicyObjective` のオブジェクトフィールドは、初回のリクエストからコピーされます。
`Metric` オブジェクトには、推論レコメンデーションジョブでベンチマークされたメトリクスと、インスタンスの使用率が `TargetCpuUtilizationPerCore` 値と同じになる場合の各メトリクスの値の計算が一覧表示されます。これは、推奨されている自動スケーリングポリシーを使用してエンドポイントがスケールイン/スケールアウトするときに、エンドポイントのパフォーマンスメトリクスを予測するのに役立ちます。たとえば、推論レコメンデーションジョブでインスタンスの使用率が 50% で、`InvocationsPerInstance` 値がもとは `4` だったとします。自動スケーリングレコメンデーションリクエストで `TargetCpuUtilizationPerCore` 値を 100% に指定した場合、2 倍のインスタンス使用率を割り当てると予想していたため、レスポンスで返される `InvocationsPerInstance` メトリクス値は `2` になります。
`DynamicScalingConfiguration` オブジェクトは、[PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html) API を呼び出すと、[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html#autoscaling-PutScalingPolicy-request-TargetTrackingScalingPolicyConfiguration) に指定する必要がある値を返します。これには、推奨される最小容量と最大容量の値、スケールインとスケールアウトの推奨クールダウン時間、各メトリックスに指定する必要がある推奨 `TargetValue` を含む `ScalingPolicies` オブジェクトが含まれます。
# カスタムロードテストを実行する
Amazon SageMaker Inference Recommender のロードテストでは、レイテンシーとスループット、カスタムトラフィックパターン、選択したサーバーレスエンドポイントまたはリアルタイムのインスタンス (最大 10) の本番要件に基づいて、広範なベンチマークが実行されます。
以下のセクションでは、 と を使用してプログラムでロードテストを作成、説明 AWS SDK for Python (Boto3) AWS CLI、停止する方法、または Amazon SageMaker Studio Classic または SageMaker AI コンソールをインタラクティブに使用する方法を示します。
## ロードテストジョブを作成する
を使用してプログラムで負荷テストを作成するか AWS SDK for Python (Boto3)、 を使用して負荷テストを作成するか AWS CLI、Studio Classic または SageMaker AI コンソールを使用してインタラクティブに負荷テストを作成します。Inference Recommender の推論レコメンデーションと同様に、モデルをモデルレジストリに登録したときのロードテストのジョブ名、IAM AWS ロール ARN、入力設定、およびモデルパッケージ ARN を指定します。ロードテストでは、トラフィックパターンと停止条件も指定する必要があります。
------
#### [ AWS SDK for Python (Boto3) ]
`CreateInferenceRecommendationsJob` API を使用して、Inference Recommender のロードテストを作成します。`JobType` フィールドで `Advanced` を指定し、以下を指定します。
+ ロードテストのジョブ名 (`JobName`)。ジョブ名は、 AWS リージョン内および AWS アカウント内で一意である必要があります。
+ Inference Recommender がユーザーに代わってタスクを実行できるようにする IAM ロールの Amazon リソースネーム (ARN)。これを `RoleArn` フィールドで定義します。
+ エンドポイント設定ディクショナリ (`InputConfig`)。以下を指定します。
+ `TrafficPattern` では、フェーズまたは階段状トラフィックパターンを指定します。フェーズトラフィックパターンでは、指定したレートで新しいユーザーが毎分生成されます。階段状トラフィックパターンでは、指定したレートで新しいユーザーが時間間隔 (*またはステップ数*) 単位で生成されます。次のいずれかを選択します。
+ `TrafficType` の場合、`PHASES` を指定します。次に、`Phases` アレイには、`InitialNumberOfUsers` (開始時の同時ユーザー数 (最小 1、最大 3))、`SpawnRate` (ロードテストの特定のフェーズで 1 分間に生成されるユーザー数 (最小 0、最大 3))、`DurationInSeconds` (トラフィックのフェーズの長さ (最小 120、最大 3600)) を指定します。
+ `TrafficType` の場合、`STAIRS` を指定します。次に、`Stairs` アレイには、`DurationInSeconds` (トラフィックのフェーズの長さ (最小 120、最大 3600)）、`NumberOfSteps` (フェーズで使用する間隔数）、`UsersPerStep` (各間隔で追加するユーザー数) を指定します。各ステップの長さは `DurationInSeconds / NumberOfSteps` の値であることに注意してください。たとえば、`DurationInSeconds` が `600` の場合、`5` ステップを指定すると、各ステップの長さは 120 秒になります。
**注記**
ユーザーは、Inference Recommender の一部としてループ内で実行され、エンドポイントへのリクエストを呼び出すシステム生成アクターとして定義されます。`ml.c5.large` インスタンス上で実行される一般的な XGBoost コンテナの場合、エンドポイントは、わずか 15～20 人のユーザーで 1 分あたり 30,000 回の呼び出し (500 tps) に達することがあります。
+ `ResourceLimit` には、`MaxNumberOfTests` (Inference Recommender ジョブのベンチマークロードテストの最大数 (最小 1、最大 10)) と `MaxParallelOfTests` (Inference Recommender ジョブの並列ベンチマークロードテストの最大数 (最小 1、最大 10)) を指定します。
+ `EndpointConfigurations` には、以下のいずれかを指定できます。
+ `InstanceType` フィールド。ロードテストを実行するインスタンスタイプを指定します。
+ `ServerlessConfig`。サーバーレスエンドポイントの `MaxConcurrency` および `MemorySizeInMB` の理想的な値を指定します。詳細については、[サーバーレス推論ドキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html)を参照してください。
+ 停止条件ディクショナリ (`StoppingConditions`)。いずれかの条件が満たされると、Inference Recommender のジョブが停止します。この例では、ディクショナリで以下のフィールドを指定します。
+ `MaxInvocations` には、エンドポイントで想定される 1 分あたりの最大リクエスト数を指定します (最小 1、最大 30,000)。
+ `ModelLatencyThresholds` には、`Percentile` (モデルレイテンシーのパーセンタイルのしきい値) と `ValueInMilliseconds` (モデルレイテンシーのパーセンタイル値 (ミリ秒単位)) を指定します。
+ (オプション) `FlatInvocations` では、TPS (1 分あたりの呼び出し数) レートが平坦化したときにロードテストを続行するかどうかを指定できます。TPS レートが平坦化すると通常、エンドポイントがキャパシティに達したことを意味します。ただし、フルキャパシティ条件でエンドポイントの監視を継続したほうが良い場合があります。このような場合でもロードテストを続行するには、この値を `Continue` として指定します。それ以外の場合、デフォルト値は `Stop` です。
```
# Create a low-level SageMaker service client.
import boto3
aws_region=
sagemaker_client=boto3.client('sagemaker', region=aws_region)
# Provide a name to your recommendation based on load testing
load_test_job_name=""
# Provide the name of the sagemaker instance type
instance_type=""
# Provide the IAM Role that gives SageMaker permission to access AWS services
role_arn='arn:aws:iam:::role/*'
# Provide your model package ARN that was created when you registered your
# model with Model Registry
model_package_arn='arn:aws:sagemaker:::role/*'
sagemaker_client.create_inference_recommendations_job(
JobName=load_test_job_name,
JobType="Advanced",
RoleArn=role_arn,
InputConfig={
'ModelPackageVersionArn': model_package_arn,
"JobDurationInSeconds": 7200,
'TrafficPattern' : {
# Replace PHASES with STAIRS to use the stairs traffic pattern
'TrafficType': 'PHASES',
'Phases': [
{
'InitialNumberOfUsers': 1,
'SpawnRate': 1,
'DurationInSeconds': 120
},
{
'InitialNumberOfUsers': 1,
'SpawnRate': 1,
'DurationInSeconds': 120
}
]
# Uncomment this section and comment out the Phases object above to use the stairs traffic pattern
# 'Stairs' : {
# 'DurationInSeconds': 240,
# 'NumberOfSteps': 2,
# 'UsersPerStep': 2
# }
},
'ResourceLimit': {
'MaxNumberOfTests': 10,
'MaxParallelOfTests': 3
},
"EndpointConfigurations" : [{
'InstanceType': 'ml.c5.xlarge'
},
{
'InstanceType': 'ml.m5.xlarge'
},
{
'InstanceType': 'ml.r5.xlarge'
}]
# Uncomment the ServerlessConfig and comment out the InstanceType field if you want recommendations for a serverless endpoint
# "ServerlessConfig": {
# "MaxConcurrency": value,
# "MemorySizeInMB": value
# }
},
StoppingConditions={
'MaxInvocations': 1000,
'ModelLatencyThresholds':[{
'Percentile': 'P95',
'ValueInMilliseconds': 100
}],
# Change 'Stop' to 'Continue' to let the load test continue if invocations flatten
'FlatInvocations': 'Stop'
}
)
```
`CreateInferenceRecommendationsJob` に渡すことができるオプションの引数と必須の引数の完全なリストについては、[Amazon SageMaker API リファレンスガイド](https://docs.aws.amazon.com/sagemaker/latest/APIReference/Welcome.html)を参照してください。
------
#### [ AWS CLI ]
`create-inference-recommendations-job` API を使用して、Inference Recommender のロードテストを作成します。`JobType` フィールドで `Advanced` を指定し、以下を指定します。
+ ロードテストのジョブ名 (`job-name`)。ジョブ名は、 AWS リージョン内および AWS アカウント内で一意である必要があります。
+ Inference Recommender がユーザーに代わってタスクを実行できるようにする IAM ロールの Amazon リソースネーム (ARN)。これを `role-arn` フィールドで定義します。
+ エンドポイント設定ディクショナリ (`input-config`)。以下を指定します。
+ `TrafficPattern` では、フェーズまたは階段状トラフィックパターンを指定します。フェーズトラフィックパターンでは、指定したレートで新しいユーザーが毎分生成されます。階段状トラフィックパターンでは、指定したレートで新しいユーザーが時間間隔 (*またはステップ数*) 単位で生成されます。次のいずれかを選択します。
+ `TrafficType` の場合、`PHASES` を指定します。次に、`Phases` アレイには、`InitialNumberOfUsers` (開始時の同時ユーザー数 (最小 1、最大 3))、`SpawnRate` (ロードテストの特定のフェーズで 1 分間に生成されるユーザー数 (最小 0、最大 3))、`DurationInSeconds` (トラフィックのフェーズの長さ (最小 120、最大 3600)) を指定します。
+ `TrafficType` の場合、`STAIRS` を指定します。次に、`Stairs` アレイには、`DurationInSeconds` (トラフィックのフェーズの長さ (最小 120、最大 3600)）、`NumberOfSteps` (フェーズで使用する間隔数）、`UsersPerStep` (各間隔で追加するユーザー数) を指定します。各ステップの長さは `DurationInSeconds / NumberOfSteps` の値であることに注意してください。たとえば、`DurationInSeconds` が `600` の場合、`5` ステップを指定すると、各ステップの長さは 120 秒になります。
**注記**
ユーザーは、Inference Recommender の一部としてループ内で実行され、エンドポイントへのリクエストを呼び出すシステム生成アクターとして定義されます。`ml.c5.large` インスタンス上で実行される一般的な XGBoost コンテナの場合、エンドポイントは、わずか 15～20 人のユーザーで 1 分あたり 30,000 回の呼び出し (500 tps) に達することがあります。
+ `ResourceLimit` には、`MaxNumberOfTests` (Inference Recommender ジョブのベンチマークロードテストの最大数 (最小 1、最大 10)) と `MaxParallelOfTests` (Inference Recommender ジョブの並列ベンチマークロードテストの最大数 (最小 1、最大 10)) を指定します。
+ `EndpointConfigurations` には、以下のいずれかを指定できます。
+ `InstanceType` フィールド。ロードテストを実行するインスタンスタイプを指定します。
+ `ServerlessConfig`。サーバーレスエンドポイントの `MaxConcurrency` および `MemorySizeInMB` の理想的な値を指定します。
+ 停止条件ディクショナリ (`stopping-conditions`)。いずれかの条件が満たされると、Inference Recommender のジョブが停止します。この例では、ディクショナリで以下のフィールドを指定します。
+ `MaxInvocations` には、エンドポイントで想定される 1 分あたりの最大リクエスト数を指定します (最小 1、最大 30,000)。
+ `ModelLatencyThresholds` には、`Percentile` (モデルレイテンシーのパーセンタイルのしきい値) と `ValueInMilliseconds` (モデルレイテンシーのパーセンタイル値 (ミリ秒単位)) を指定します。
+ (オプション) `FlatInvocations` では、TPS (1 分あたりの呼び出し数) レートが平坦化したときにロードテストを続行するかどうかを指定できます。TPS レートが平坦化すると通常、エンドポイントがキャパシティに達したことを意味します。ただし、フルキャパシティ条件でエンドポイントの監視を継続したほうが良い場合があります。このような場合でもロードテストを続行するには、この値を `Continue` として指定します。それ以外の場合、デフォルト値は `Stop` です。
```
aws sagemaker create-inference-recommendations-job\
--region \
--job-name \
--job-type ADVANCED\
--role-arn arn:aws:iam:::role/*\
--input-config \"{
\"ModelPackageVersionArn\": \"arn:aws:sagemaker:::role/*\",
\"JobDurationInSeconds\": 7200,
\"TrafficPattern\" : {
# Replace PHASES with STAIRS to use the stairs traffic pattern
\"TrafficType\": \"PHASES\",
\"Phases\": [
{
\"InitialNumberOfUsers\": 1,
\"SpawnRate\": 60,
\"DurationInSeconds\": 300
}
]
# Uncomment this section and comment out the Phases object above to use the stairs traffic pattern
# 'Stairs' : {
# 'DurationInSeconds': 240,
# 'NumberOfSteps': 2,
# 'UsersPerStep': 2
# }
},
\"ResourceLimit\": {
\"MaxNumberOfTests\": 10,
\"MaxParallelOfTests\": 3
},
\"EndpointConfigurations\" : [
{
\"InstanceType\": \"ml.c5.xlarge\"
},
{
\"InstanceType\": \"ml.m5.xlarge\"
},
{
\"InstanceType\": \"ml.r5.xlarge\"
}
# Use the ServerlessConfig and leave out the InstanceType fields if you want recommendations for a serverless endpoint
# \"ServerlessConfig\": {
# \"MaxConcurrency\": value,
# \"MemorySizeInMB\": value
# }
]
}\"
--stopping-conditions \"{
\"MaxInvocations\": 1000,
\"ModelLatencyThresholds\":[
{
\"Percentile\": \"P95\",
\"ValueInMilliseconds\": 100
}
],
# Change 'Stop' to 'Continue' to let the load test continue if invocations flatten
\"FlatInvocations\": \"Stop\"
}\"
```
------
#### [ Amazon SageMaker Studio Classic ]
Studio Classic でロードテストを作成します。
1. Studio Classic アプリケーションで、ホームアイコン (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/studio/icons/house.png)) を選択します。
1. Studio Classic の左側のサイドバーで **[デプロイ]** を選択します。
1. ドロップダウンリストから **[推論レコメンダー]** を選択します。
1. **[推論レコメンダージョブを作成]** を選択します。右側ペインに、**[推論レコメンダージョブを作成]** という新しいタブが開きます。
1. **[モデルグループ]** フィールドのドロップダウンからモデルグループの名前を選択します。リストには、Studio Classic 以外で登録されたモデルを含む、アカウントのモデルレジストリに登録されているすべてのモデルグループが含まれます。
1. **[モデルバージョン]** フィールドのドロップダウンからモデルのバージョンを選択します。
1. **[続行]** をクリックします。
1. **[Name]** (名前) フィールドにジョブの名前を入力します。
1. （オプション）ジョブに関する説明を**[Description]** (説明) フィールドに入力します。
1. Inference Recommender に AWS サービスへのアクセス許可を付与する IAM ロールを選択します。これを行うには、ロールを作成して `AmazonSageMakerFullAccess` IAM 管理ポリシーをアタッチするか、Studio Classic にロールを作成させることもできます。
1. **[停止条件]** を選択し、使用できる入力フィールドを展開します。デプロイのレコメンデーションを停止するための一連の条件を指定します。
1. エンドポイントで予想される 1 分あたりの最大リクエスト数を**[Max Invocations Per Minute]** (1 分あたりの最大呼び出し回数) フィールドに指定します。
1. モデルレイテンシーのしきい値を、**[Model Latency Threshold]** (モデルのレイテンシーしきい値) フィールドにマイクロ秒単位で指定します。**[Model Latency Threshold]** (モデルのレイテンシーしきい値) は、Inference Recommender から見た、モデルが応答するのにかかる時間の間隔を示しています。この間隔には、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかるローカル通信時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。
1. **[Traffic Pattern]** (トラフィックパターン) を選択して、使用できる入力フィールドを展開します。
1. **[Initial Number of Users] (初期ユーザー数)** フィールドに整数値を指定して、仮想ユーザーの初期数を設定します。
1. **[Spawn Rate]** (スポーンレート) フィールドに整数値を指定します。スポーンレートは、1 秒間に作成されるユーザー数を設定します。
1. **[Duration]** (期間) フィールドに整数値を指定して、フェーズの期間を秒単位で設定します。
1. (オプション) トラフィックパターンを追加します。追加するには、**[Add]** (追加) を選択します。
1. **[Additional]** (追加) 設定を選択すると、**[Max test duration]** (最大テスト期間) フィールドが表示されます。ジョブ中にテストを実行できる最大時間を秒単位で指定します。新しいジョブは、定義された期間後には予定されません。これにより、進行中のジョブが停止されず、完了したジョブのみを表示できるようになります。
1. **[続行]** をクリックします。
1. **[Selected Instances]** (選択したインスタンス) を選択します。
1. **[Instances for benchmarking]** (ベンチマークするインスタンス) フィールドで、**[Add instances to test]** (テストするインスタンスを追加する) を選択します。Inference Recommender でロードテストに使用するインスタンスを最大 10 個選択します。
1. **[Additional settings]** (追加設定) を選択します。
1. ジョブが実行できるテストの数に上限を設定する整数を **[Max number of tests]** (テストの最大数) フィールドに指定します。各エンドポイント設定では、新しいロードテストが行われます。
1. **[Max parallel]** (最大並列値) テストフィールドに整数を指定します。この設定では、並列に実行できるロードテスト数の上限を定義します。
1. **[Submit]** (送信) を選択します。
ロードテストには最大 2 時間かかることがあります。
**警告**
このタブを閉じないでください。このタブを閉じると、Inference Recommender のロードテストジョブがキャンセルされます。
------
#### [ SageMaker AI console ]
次の手順を実行して、SageMaker AI コンソールからカスタムロードテストを作成します。
1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) に移動します。
1. 左側のナビゲーションペインで、**[推論]** を選択し、次に **[推論レコメンダー]** を選択します。
1. **[推論レコメンダージョブ]** ページで **[ジョブを作成]** を選択します。
1. **[ステップ 1: モデル設定]** で、以下の操作を行います。
1. **[ジョブタイプ]** には、**[高度なレコメンダージョブ]** を選択します。
1. SageMaker AI モデルレジストリに登録されているモデルを使用する場合は、**[モデルレジストリからモデルを選択]** トグルをオンにして、以下の操作を行います。
1. **[モデルグループ]** ドロップダウンリストでは、モデルがある SageMaker AI モデルレジストリ内のモデルグループを選択します。
1. **[モデルバージョン]** ドロップダウンリストでは、目的のバージョンのモデルを選択します。
1. SageMaker AI で作成したモデルを使用する場合は、**[モデルレジストリからモデルを選択]** トグルをオフにして、以下の操作を行います。
1. **[モデル名]** フィールドには、SageMaker AI モデルの名前を入力します。
1. **IAM ロール**では、インスタンスレコメンデーションジョブを作成するために必要なアクセス許可を持つ既存の AWS IAM ロールを選択できます。または、既存のロールがない場合は、**[新しいロールの作成]** を選択してロール作成ポップアップを開くと、SageMaker AI によって作成した新しいロールに必要な権限が追加されます。
1. **[ペイロードをベンチマークするための S3 バケット]** には、サンプルペイロードアーカイブへの Amazon S3 パスを入力します。これには、Inference Recommender がさまざまなインスタンスタイプでモデルをベンチマークするために使用するサンプルペイロードファイルが含まれている必要があります。
1. **[ペイロードコンテンツタイプ]** には、サンプルペイロードデータの MIME タイプを入力します。
1. **[トラフィックパターン]** では、次の手順を実行してロードテストのフェーズを設定します。
1. **[初期ユーザー数]** には、開始時の同時ユーザー数を指定します (最小 1、最大 3)。
1. **[生成レート]** には、そのフェーズで 1 分間に生成されるユーザー数を指定します (最小 0、最大 3)。
1. **[所要時間 (秒)]** では、トラフィックフェーズをどの程度短くするかを秒単位で指定します (最小 120、最大 3600)。
1. (オプション) **[モデルレジストリからモデルを選択]** トグルをオフにし、SageMaker AI モデルを指定した場合は、**[コンテナの設定]** で以下の操作を行います。
1. **[ドメイン]** ドロップダウンリストでは、コンピュータビジョン、自然言語処理、機械学習など、モデルの機械学習ドメインを選択します。
1. **[フレームワーク]** ドロップダウンリストでは、TensorFlow や XGBoost など、コンテナのフレームワークを選択します。
1. **[フレームワークバージョン]** には、コンテナイメージのフレームワークバージョンを入力します。
1. **[最も近いモデル名]** ドロップダウンリストでは、自分のモデルと最もよく一致する事前トレーニング済みのモデルを選択します。
1. **[タスク]** ドロップダウンリストでは、画像分類やリグレッションなど、モデルが実行する機械学習タスクを選択します。
1. (オプション) **[SageMaker Neo を使用したモデルコンパイル]** では、SageMaker Neo を使用してコンパイルしたモデルのレコメンデーションジョブを設定できます。**[データ入力設定]** には、モデルに適した入力データ形状を `{'input':[1,1024,1024,3]}` のような形式で入力します。
1. [**次へ**] を選択します。
1. **[ステップ 2: インスタンスと環境パラメータ]** では、以下の操作を行います。
1. **[ベンチマーキング用のインスタンスを選択]** では、ベンチマークするインスタンスタイプを最大 8 個選択します。
1. (オプション) **[環境パラメータの範囲]** では、モデルの最適化に役立つ環境パラメータを指定できます。パラメータは **キー**と**値**のペアとして指定します。
1. [**次へ**] を選択します。
1. **[ステップ 3: ジョブパラメータ]** では、以下の操作を行います。
1. (オプション) **[ジョブ名]** フィールドに、インスタンスレコメンデーションジョブの名前を入力します。ジョブを作成すると、SageMaker AI によってこの名前の末尾にタイムスタンプが追加されます。
1. (オプション) **[ジョブの説明]** に、ジョブの説明を入力します。
1. (オプション) **暗号化キー**ドロップダウンリストで、名前で AWS KMS キーを選択するか、ARN を入力してデータを暗号化します。
1. (オプション) **[テストの最大数]** には、レコメンデーションジョブ中に実行するテストの数を入力します。
1. (オプション) **[最大並列テスト]** には、レコメンデーションジョブ中に実行する並列テストの最大数を入力します。
1. **[最大テスト時間]** には、各テストを実行する最大秒数を入力します。
1. **[1 分あたりの最大呼び出し数]** には、推奨ジョブを停止するまでにエンドポイントが到達できる 1 分あたりの最大リクエスト数を入力します。この制限に達すると、SageMaker AI はジョブを終了します。
1. **[P99 モデルレイテンシーのしきい値]** には、モデルレイテンシーのパーセンタイルをミリ秒単位で入力します。
1. [**次へ**] を選択します。
1. **[ステップ 4: ジョブを確認]** では、設定を確認して **[送信]** を選択します。
------
## ロードテスト結果を取得する
負荷テストが完了したら AWS SDK for Python (Boto3)、、、Studio Classic AWS CLI、または SageMaker AI コンソールを使用して、すべての負荷テストのメトリクスをプログラムで収集できます。
------
#### [ AWS SDK for Python (Boto3) ]
`DescribeInferenceRecommendationsJob` API でメトリクスを収集します。`JobName` フィールドにロードテストのジョブ名を指定します。
```
load_test_response = sagemaker_client.describe_inference_recommendations_job(
JobName=load_test_job_name
)
```
レスポンスオブジェクトを出力します。
```
load_test_response['Status']
```
ここでは、次の例のような JSON レスポンスが返されます。この例はリアルタイム推論に推奨されるインスタンスタイプを示していることに注意してください (サーバーレス推論レコメンデーションを示す例については、この後の例を参照してください)。
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Advanced',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 19, 38, 30, 957000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 19, 46, 31, 399000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 7200,
'TrafficPattern': {
'TrafficType': 'PHASES'
},
'ResourceLimit': {
'MaxNumberOfTests': 100,
'MaxParallelOfTests': 100
},
'EndpointConfigurations': [{
'InstanceType': 'ml.c5d.xlarge'
}]
},
'StoppingConditions': {
'MaxInvocations': 1000,
'ModelLatencyThresholds': [{
'Percentile': 'P95',
'ValueInMilliseconds': 100}
]},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.6899999976158142,
'CostPerInference': 1.0332434612791985e-05,
'MaximumInvocations': 1113,
'ModelLatency': 100000
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.xlarge',
'InitialInstanceCount': 3
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1199',
'date': 'Tue, 26 Oct 2021 19:57:42 GMT'
},
'RetryAttempts': 0}
}
```
最初の数行には、ロードテストジョブ自体に関する情報が表示されます。これには、ジョブ名、ロール ARN、作成、削除時間が含まれます。
`InferenceRecommendations` ディクショナリには、Inference Recommender 推論レコメンデーションのリストが含まれています。
`EndpointConfiguration` ネストされたディクショナリには、レコメンデーションジョブ中に使用されるエンドポイントとバリアント名 (デプロイされた AWS 機械学習モデル`InstanceType`) とともに、インスタンスタイプ () レコメンデーションが含まれています。Amazon CloudWatch Events でのモニタリングには、エンドポイントとバリアント名を使用できます。詳細については「[Amazon CloudWatch における Amazon SageMaker AI メトリクス](monitoring-cloudwatch.md)」を参照してください。
`EndpointConfiguration` のネストされたディクショナリには、インスタンス数 (`InitialInstanceCount`) レコメンデーションも含まれています。これは、`StoppingConditions` で指定されている `MaxInvocations` を満たすためにエンドポイントでプロビジョニングする必要があるインスタンス数です。たとえば、`InstanceType` が `ml.m5.large` で、`InitialInstanceCount` が `2` の場合、`MaxInvocations` 停止条件で指定された TPS を処理できるように、エンドポイントに対して 2 つの `ml.m5.large` インスタンスをプロビジョニングする必要があります。
`Metrics` のネストされたディクショナリには、リアルタイムエンドポイントの 1 時間あたりの推定コスト (`CostPerHour`) (USD)、リアルタイムエンドポイントの推論あたりの推定コスト (`CostPerInference`)、エンドポイントに送信される `InvokeEndpoint` リクエストの最大数、モデルが SageMaker AI に応答するのにかかった時間間隔 (マイクロ秒単位) である、モデルのレイテンシー (`ModelLatency`) に関する情報が含まれています。モデルのレイテンシーには、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかるローカル通信時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。
以下の例は、サーバーレス推論レコメンデーションを返すように設定されたロードテストのレスポンスの `InferenceRecommendations` 部を示しています。
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
サーバーレス推論のレコメンデーションは、リアルタイム推論の結果と同様に解釈できます。ただし、`ServerlessConfig` は例外で、ロードテストの設定時に `MaxConcurrency` と `MemorySizeInMB` に指定された値を示します。サーバーレスレコメンデーションではメトリクス `ModelSetupTime` も測定され、これにより、サーバーレスエンドポイントでコンピューターリソースを起動するのにかかる時間 (マイクロ秒単位) が測定されます。サーバーレスエンドポイントの設定について詳しくは、[サーバーレス推論のドキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html)を参照してください。
------
#### [ AWS CLI ]
`describe-inference-recommendations-job` API でメトリクスを収集します。次の `job-name` フラグにロードテストのジョブ名を指定します。
```
aws sagemaker describe-inference-recommendations-job --job-name
```
ここでは、次の例のようなレスポンスが返されます。この例はリアルタイム推論に推奨されるインスタンスタイプを示していることに注意してください (サーバーレス推論レコメンデーションを示す例については、この後の例を参照してください)。
```
{
'JobName': 'job-name',
'JobDescription': 'job-description',
'JobType': 'Advanced',
'JobArn': 'arn:aws:sagemaker:region:account-id:inference-recommendations-job/resource-id',
'Status': 'COMPLETED',
'CreationTime': datetime.datetime(2021, 10, 26, 19, 38, 30, 957000, tzinfo=tzlocal()),
'LastModifiedTime': datetime.datetime(2021, 10, 26, 19, 46, 31, 399000, tzinfo=tzlocal()),
'InputConfig': {
'ModelPackageVersionArn': 'arn:aws:sagemaker:region:account-id:model-package/resource-id',
'JobDurationInSeconds': 7200,
'TrafficPattern': {
'TrafficType': 'PHASES'
},
'ResourceLimit': {
'MaxNumberOfTests': 100,
'MaxParallelOfTests': 100
},
'EndpointConfigurations': [{
'InstanceType': 'ml.c5d.xlarge'
}]
},
'StoppingConditions': {
'MaxInvocations': 1000,
'ModelLatencyThresholds': [{
'Percentile': 'P95',
'ValueInMilliseconds': 100
}]
},
'InferenceRecommendations': [{
'Metrics': {
'CostPerHour': 0.6899999976158142,
'CostPerInference': 1.0332434612791985e-05,
'MaximumInvocations': 1113,
'ModelLatency': 100000
},
'EndpointConfiguration': {
'EndpointName': 'endpoint-name',
'VariantName': 'variant-name',
'InstanceType': 'ml.c5d.xlarge',
'InitialInstanceCount': 3
},
'ModelConfiguration': {
'Compiled': False,
'EnvironmentParameters': []
}
}],
'ResponseMetadata': {
'RequestId': 'request-id',
'HTTPStatusCode': 200,
'HTTPHeaders': {
'x-amzn-requestid': 'x-amzn-requestid',
'content-type': 'content-type',
'content-length': '1199',
'date': 'Tue, 26 Oct 2021 19:57:42 GMT'
},
'RetryAttempts': 0
}
}
```
最初の数行には、ロードテストジョブ自体に関する情報が表示されます。これには、ジョブ名、ロール ARN、作成、削除時間が含まれます。
`InferenceRecommendations` ディクショナリには、Inference Recommender 推論レコメンデーションのリストが含まれています。
`EndpointConfiguration` ネストされたディクショナリには、レコメンデーションジョブ中に使用されるエンドポイントとバリアント名 (デプロイされた AWS 機械学習モデル`InstanceType`) とともに、インスタンスタイプ () レコメンデーションが含まれています。Amazon CloudWatch Events でのモニタリングには、エンドポイントとバリアント名を使用できます。詳細については「[Amazon CloudWatch における Amazon SageMaker AI メトリクス](monitoring-cloudwatch.md)」を参照してください。
`Metrics` のネストされたディクショナリには、リアルタイムエンドポイントの 1 時間あたりの推定コスト (`CostPerHour`) (USD)、リアルタイムエンドポイントの推論あたりの推定コスト (`CostPerInference`)、エンドポイントに送信される `InvokeEndpoint` リクエストの最大数、モデルが SageMaker AI に応答するのにかかった時間間隔 (マイクロ秒単位) である、モデルのレイテンシー (`ModelLatency`) に関する情報が含まれています。モデルのレイテンシーには、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかるローカル通信時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。
以下の例は、サーバーレス推論レコメンデーションを返すように設定されたロードテストのレスポンスの `InferenceRecommendations` 部を示しています。
```
"InferenceRecommendations": [
{
"EndpointConfiguration": {
"EndpointName": "value",
"InitialInstanceCount": value,
"InstanceType": "value",
"VariantName": "value",
"ServerlessConfig": {
"MaxConcurrency": value,
"MemorySizeInMb": value
}
},
"InvocationEndTime": value,
"InvocationStartTime": value,
"Metrics": {
"CostPerHour": value,
"CostPerInference": value,
"CpuUtilization": value,
"MaxInvocations": value,
"MemoryUtilization": value,
"ModelLatency": value,
"ModelSetupTime": value
},
"ModelConfiguration": {
"Compiled": "False",
"EnvironmentParameters": [],
"InferenceSpecificationName": "value"
},
"RecommendationId": "value"
}
]
```
サーバーレス推論のレコメンデーションは、リアルタイム推論の結果と同様に解釈できます。ただし、`ServerlessConfig` は例外で、ロードテストの設定時に `MaxConcurrency` と `MemorySizeInMB` に指定された値を示します。サーバーレスレコメンデーションではメトリクス `ModelSetupTime` も測定され、これにより、サーバーレスエンドポイントでコンピューターリソースを起動するのにかかる時間 (マイクロ秒単位) が測定されます。サーバーレスエンドポイントの設定について詳しくは、[サーバーレス推論のドキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints.html)を参照してください。
------
#### [ Amazon SageMaker Studio Classic ]
レコメンデーションは、Studio Classic 内の **[推論レコメンデーション]** という新しいタブに表示されます。結果が表示されるまでに最大 2 時間かかることがあります。このタブには、**[Results]** (結果) と **[Details]** (詳細) 列が含まれています。
**[Details]** (詳細) 列には、ロードテストジョブに指定された名前やジョブの作成日時 (**[Creation time]** (作成日時)) など、ロードテストジョブに関する情報が表示されます。また、1 分あたりに発生した最大呼び出し数や、使用された Amazon リソースネーム (ARN) といった、**[Settings]** (設定) 情報も表示されます。
**[結果]** 列には、**[デプロイの目標]** と **[SageMaker AI レコメンデーション]** ウィンドウが表示され、デプロイの重要度に基づいて結果が表示される順序を調整できます。ユースケースの **[Cost]** (コスト)、**[Latency]** (レイテンシー)、**[Throughput]** (スループット) の重要レベルを指定できる 3 つのドロップダウンメニューがあります。目標（コスト、レイテンシー、スループット）ごとに、**最小重要度**、**低重要度**、**中重要度**、**高重要度**、または**最高重要度**の重要度のレベルを設定できます。
各目標の重要度の選択に基づいて、Inference Recommender はその最上位レコメンデーションを、パネル右側の **[SageMaker recommendation]** (SageMaker レコメンデーション)フィールドに、時間あたりの推定コストと推論リクエストとともに表示します。また、予想されるモデルのレイテンシー、最大呼び出し数、インスタンス数に関する情報も表示されます。
表示される上位のレコメンデーションに加えて、Inference Recommender がテストしたすべてのインスタンスについての同じ情報が**[All runs]** (すべての実行) セクションに表示されます。
------
#### [ SageMaker AI console ]
次の手順を実行して、SageMaker AI コンソールにカスタムロードテストジョブの結果を表示します。
1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) に移動します。
1. 左側のナビゲーションペインで、**[推論]** を選択し、次に **[推論レコメンダー]** を選択します。
1. **[推論レコメンダージョブ]** ページで、推論レコメンデーションジョブの名前を選択します。
ジョブの詳細ページでは、以下のスクリーンショットに示すように、SageMaker AI がモデルに推奨するインスタンスタイプである **[推論のレコメンデーション]** を表示できます。
![\[SageMaker AI コンソールのジョブ詳細ページにある推論レコメンデーションリストのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inf-rec-instant-recs.png)
このセクションでは、**[モデルレイテンシー]**、**[1 時間あたりのコスト]**、**[推論あたりのコスト]**、**[1 分あたりの呼び出し]** などのさまざまな要因でインスタンスタイプを比較できます。
このページでは、ジョブに指定した設定も表示できます。**[モニター]** セクションでは、インスタンスタイプごとに記録された Amazon CloudWatch メトリクスを表示できます。これらのメトリクスの解釈について詳しくは、「[結果の解釈](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-interpret-results.html)」を参照してください。
------
# ロードテストを停止する
ジョブを誤って開始した場合や、ジョブを実行する必要がなくなった場合は、現在実行中のジョブを停止できます。`StopInferenceRecommendationsJob` API を使用するか、Studio Classic または SageMaker AI コンソールから、ロードテストジョブをプログラムで停止します。
------
#### [ AWS SDK for Python (Boto3) ]
`JobName` フィールドにロードテストのジョブ名を指定します。
```
sagemaker_client.stop_inference_recommendations_job(
JobName=''
)
```
------
#### [ AWS CLI ]
次の `job-name` フラグにロードテストのジョブ名を指定します。
```
aws sagemaker stop-inference-recommendations-job --job-name
```
------
#### [ Amazon SageMaker Studio Classic ]
カスタムロードジョブを開始したタブを閉じて、Inference Recommender のロードテストを停止します。
------
#### [ SageMaker AI console ]
SageMaker AI コンソールからロードテストジョブを停止するには、以下の操作を行います。
1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) に移動します。
1. 左側のナビゲーションペインで、**[推論]** を選択し、次に **[推論レコメンダー]** を選択します。
1. **[推論レコメンダージョブ]** ページで、ロードテストジョブを選択します。
1. **[ジョブを停止]** を選択します。
1. ポップアップ表示されるダイアログボックスで、**[確認]** を選択します。
ジョブを停止すると、ジョブの **[ステータス]** が **[停止中]** に変わります。
------
# Inference Recommender エラーのトラブルシューティング
このセクションでは、一般的なエラーを理解して防止する方法、それらが生成するエラーメッセージ、これらのエラーを解決する方法に関するガイダンスについて説明します。
## トラブルシューティング方法
次の手順を実行することによって、エラーの解決を試みます。
+ Inference Recommender を使用するための前提条件をすべて満たしているかどうかを確認します。[Inference Recommender の前提条件](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-prerequisites.html)を参照してください。
+ モデルをモデルレジストリからエンドポイントにデプロイできること、およびペイロードをエラーなく処理できることを確認します。「[Deploy a Model from the Registry](https://docs.aws.amazon.com/sagemaker/latest/dg/model-registry-deploy.html)」を参照してください。
+ Inference Recommender のジョブを開始すると、作成されるエンドポイントがコンソールに表示され、CloudWatch ログを確認できます。
## 一般的なエラー
Inference Recommender の一般的なエラーとその解決方法については、以下の表をご覧ください。
| エラー | 解決策 |
| --- | --- |
| モデルパッケージのバージョン 1 で `Domain` を指定してください。`Domain` はジョブの必須パラメータです。 | 必ず機械学習ドメインを指定してください。不明な場合は、`OTHER` を入力します。 |
| 指定したロール ARN が引き受けられず、`AWSSecurityTokenServiceException` エラーが発生しました。 | 指定した実行ロールに、前提条件で指定された必要な許可が付与されていることを確認してください。 |
| モデルパッケージのバージョン 1 で `Framework` を指定します。`Framework` はジョブの必須パラメータです。 | 必ず機械学習フレームワークを指定してください。不明な場合は、`OTHER` を入力します。 |
| 前フェーズの終了時のユーザー数が 0 で、現在のフェーズの初期ユーザー数は 1 です。 | ここでいうユーザーとは、リクエストの送信に使用される仮想ユーザーまたはスレッドを指します。各フェーズは A ユーザーで始まり、B > A というように B ユーザーで終わります。連続するフェーズ x\$11 と x\$12 の間では、abs(x\$12.A - x\$11.B) <= 3 および >= 0 となる必要があります。 |
| 総トラフィック時間 (全体) はジョブ時間を超えてはいけません。 | すべてのフェーズの合計期間がジョブ時間を超えることはできません。 |
| バースト可能なインスタンスタイプ ml.t2.medium は使用できません。 | バースト可能なインスタンスでは一貫したパフォーマンスが得られないため、Inference Recommender は t2 インスタンスファミリーでのロードテストをサポートしていません。 |
| CreateEndpoint オペレーション呼び出し時の ResourceLimitExceeded | SageMaker AI のリソース制限を超えました。たとえば、アカウントがエンドポイントのクォータに達した場合、Inference Recommender はベンチマーク用のエンドポイントをプロビジョニングできなくなる可能性があります。SageMaker AI の制限とクォータの詳細については、「[Amazon SageMaker AI endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html)」を参照してください。 |
| InvokeEndpoint オペレーション呼び出し時の ModelError | モデルエラーは、次の理由で発生する可能性があります。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/inference-recommender-troubleshooting.html) |
| InvokeEndpoint オペレーション呼び出し時の PayloadError | ペイロードエラーは、次の理由で発生する可能性があります。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/inference-recommender-troubleshooting.html) |
## CloudWatch をチェックする
Inference Recommender のジョブを開始すると、作成されるエンドポイントがコンソールに表示されます。いずれかのエンドポイントを選択し、CloudWatch ログを表示して 4xx/5xx エラーがないかを監視します。Inference Recommender ジョブが成功すると、結果の一部としてエンドポイント名が表示されます。Inference Recommender ジョブが失敗した場合でも、以下の手順に従って、削除されたエンドポイントの CloudWatch ログを確認できます。
1. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) で Amazon CloudWatch コンソールを開きます。
1. 右上の **[リージョン]** ドロップダウンリストから、Inference Recommender ジョブを作成したリージョンを選択します。
1. CloudWatch のナビゲーションペインで、**[ログ]**、**[ロググループ]** の順に選択します。
1. `/aws/sagemaker/Endpoints/sm-epc-*` という名前のロググループを検索します。最新の Inference Recommender ジョブに基づいてロググループを選択します。
Inference Recommender CloudWatch ログを確認して、ジョブのトラブルシューティングを行うこともできます。`/aws/sagemaker/InferenceRecommendationsJobs` CloudWatch ロググループで発行される Inference Recommender ログでは、`/execution` ログストリームでジョブの進行状況に関する概要が示されます。テスト中の各エンドポイント設定に関する詳細情報は、`/Endpoint/` ログストリームで確認できます。
** Inference Recommender ログストリームの概要**
+ `/execution` には、ベンチマークが予定されているエンドポイント設定、コンパイルジョブのスキップ理由、検証失敗理由など、ジョブ全体の情報が含まれています。
+ `/Endpoint/` には、リソース作成の進捗状況、テスト設定、ロードテストの停止理由、リソースのクリーンアップステータスなどの情報が含まれています。
+ `/CompilationJob/` には、Inference Recommender によって作成されたコンパイルジョブに関する情報 (コンパイルジョブの構成やコンパイルジョブのステータスなど) が含まれています。
**Inference Recommender のエラーメッセージのアラームを作成する**
Inference Recommender は、トラブルシューティング時に役立つエラーのログステートメントを出力します。CloudWatch ロググループとメトリクスフィルターを使用すると、データが CloudWatch に送信された時に、このログデータの用語やパターンを検索することができます。次に、ロググループのメトリクスフィルターに基づいて CloudWatch アラームを作成します。詳細については、「[ロググループのメトリクスフィルターに基づく CloudWatch アラームの作成](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Create_alarm_log_group_metric_filter.html)」を参照してください。
## ベンチマークをチェックする
Inference Recommender ジョブを開始すると、Inference Recommender によって複数のベンチマークが作成され、さまざまなインスタンスタイプのモデルのパフォーマンスが評価されます。[ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html) API を使用すると、すべてのベンチマークの詳細を表示できます。ベンチマークが失敗した場合は、結果の一部として失敗の理由を確認できます。
[ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html) API を使用するには、以下の値を指定します。
+ `JobName` には、Inference Recommender ジョブの名前を指定します。
+ `StepType` には、`BENCHMARK` を使用して、ジョブのベンチマークに関する詳細情報を返します。
+ `Status` には、`FAILED` を使用して、失敗したベンチマークのみに関する詳細情報を返します。他のステータスタイプのリストについては、[ListInferenceRecommendationsJobSteps](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ListInferenceRecommendationsJobSteps.html) API の `Status` フィールドを参照してください。
```
# Create a low-level SageMaker service client.
import boto3
aws_region = ''
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Provide the job name for the SageMaker Inference Recommender job
job_name = ''
# Filter for benchmarks
step_type = 'BENCHMARK'
# Filter for benchmarks that have a FAILED status
status = 'FAILED'
response = sagemaker_client.list_inference_recommendations_job_steps(
JobName = job_name,
StepType = step_type,
Status = status
)
```
レスポンスオブジェクトは、印刷して結果を表示できます。前のコード例では、`response` と呼ばれる変数にレスポンスが保存されています。
```
print(response)
```
# リアルタイム推論
リアルタイム推論は、リアルタイム、インタラクティブ、低レイテンシーの要件がある推論ワークロードに最適です。SageMaker AI ホスティングサービスにモデルをデプロイし、推論に使用できるエンドポイントを取得できます。これらのエンドポイントはフルマネージドで、オートスケーリングをサポートします (「[Amazon SageMaker AI モデルの自動スケーリング](endpoint-auto-scaling.md)」を参照)。
**Topics**
+ [リアルタイム推論用のモデルをデプロイする](realtime-endpoints-deploy-models.md)
+ [リアルタイム推論用のモデルを呼び出す](realtime-endpoints-test-endpoints.md)
+ [エンドポイント](realtime-endpoints-manage.md)
+ [ホスティングオプション](realtime-endpoints-options.md)
+ [Amazon SageMaker AI モデルの自動スケーリング](endpoint-auto-scaling.md)
+ [インスタンスストレージボリューム](host-instance-storage.md)
+ [本番環境でのモデルの検証](model-validation.md)
+ [SageMaker Clarify によるオンライン説明可能性](clarify-online-explainability.md)
+ [アダプター推論コンポーネントを使用してモデルをファインチューニングする](realtime-endpoints-adapt.md)
# リアルタイム推論用のモデルをデプロイする
**重要**
Amazon SageMaker Studio または Amazon SageMaker Studio Classic に Amazon SageMaker リソースの作成を許可するカスタム IAM ポリシーでは、これらのリソースにタグを追加するアクセス許可も付与する必要があります。Studio と Studio Classic は、作成したリソースに自動的にタグ付けするため、リソースにタグを追加するアクセス許可が必要になります。IAM ポリシーで Studio と Studio Classic によるリソースの作成が許可されていても、タグ付けが許可されていない場合は、リソースを作成しようとしたときに「AccessDenied」エラーが発生する可能性があります。詳細については、「[SageMaker AI リソースにタグ付けのアクセス許可を付与する](security_iam_id-based-policy-examples.md#grant-tagging-permissions)」を参照してください。
SageMaker リソースを作成するためのアクセス許可を付与する [AWS Amazon SageMaker AI の マネージドポリシー](security-iam-awsmanpol.md) には、それらのリソースの作成中にタグを追加するためのアクセス許可もあらかじめ含まれています。
SageMaker AI ホスティングサービスを使用してモデルをデプロイするには、複数のオプションがあります。SageMaker Studio を使用してモデルをインタラクティブにデプロイできます。または、SageMaker Python AWS SDK や SDK for Python (Boto3) などの SDK を使用してプログラムでモデルをデプロイすることもできます。を使用してデプロイすることもできます AWS CLI。
## [開始する前に]
SageMaker AI モデルをデプロイする前に、次を探して記録してください:
+ Amazon S3 バケット AWS リージョン がある 。
+ モデルアーティファクトが保存されている Amazon S3 URI パス
+ SageMaker AI の IAM ロール
+ 推論コードを含むカスタムイメージの Docker Amazon ECR URI レジストリパス、または および でサポートされている組み込み Docker イメージのフレームワークとバージョン AWS
各 AWS のサービス で使用できる のリストについては AWS リージョン、[「リージョンマップとエッジネットワーク](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/)」を参照してください。IAM ロールの作成については、「[IAM ロールの作成](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html)」を参照してください。
**重要**
モデルアーティファクトが保存されている Amazon S3 バケットは、作成するモデルと同じ AWS リージョン に存在している必要があります。
## 複数のモデルでリソース使用率を共有する
Amazon SageMaker AI を使用して、エンドポイントにモデルを 1 つまたは複数デプロイできます。複数のモデルがエンドポイントを共有する場合は、そこでホストされるリソース (ML 演算処理インスタンス、CPU、アクセラレーターなど) を共同で使用します。エンドポイントに複数のモデルを柔軟にデプロイするには、各モデルを*推論コンポーネント*として定義するのが一番です。
### 推論コンポーネント
推論コンポーネントは、モデルをエンドポイントにデプロイするために使用できる SageMaker AI ホスティングオブジェクトです。推論コンポーネント設定では、モデル、エンドポイント、およびエンドポイントがホストするリソースをモデルがどのように使用するかを指定します。モデルを指定する際、SageMaker AI Model オブジェクトを指定することも、モデルアーティファクトとイメージを直接指定することもできます。
設定では、必要な CPU コア、アクセラレータ、メモリをモデルに割り当てる方法を調整することで、リソース使用率を最適化できます。エンドポイントに複数の推論コンポーネントをデプロイし、各推論コンポーネントに 1 つのモデルと、そのモデルのリソース使用率のニーズを含めることができます。
推論コンポーネントをデプロイした後、SageMaker API で InvokeEndpoint アクションを使用すると、関連付けられたモデルを直接呼び出すことができます。
推論コンポーネントには以下の利点があります。
**柔軟性**
推論コンポーネントでは、モデルのホスティングの詳細がエンドポイント自体から切り離されます。そのため、モデルをエンドポイントでどのようにホスティングおよび提供するかを柔軟にコントロールできます。同じインフラストラクチャで複数のモデルをホスティングし、必要に応じてエンドポイントにモデルを追加または削除できます。各モデルは個別にアップデートできます。
**スケーラビリティ**
ホストする各モデルのコピー数を指定したり、モデルがリクエストを処理するために必要なコピーの最小数を設定したりできます。推論コンポーネントのコピーをゼロにスケールダウンすることで、別のコピーをスケールアップする余地を作成できます。
以下を使用してモデルをデプロイすると、SageMaker AI がモデルを推論コンポーネントとしてパッケージ化します。
+ SageMaker Studio Classic。
+ Model オブジェクトをデプロイする SageMaker Python SDK (エンドポイントタイプを `EndpointType.INFERENCE_COMPONENT_BASED` に設定した場合)。
+ エンドポイントにデプロイする`InferenceComponent`オブジェクト AWS SDK for Python (Boto3) を定義する 。
## SageMaker Studio を使用してモデルをデプロイする
SageMaker Studio を使用してモデルをインタラクティブに作成およびデプロイするには、次の手順を実行します。Studio の詳細については、[Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) のドキュメントを参照してください。さまざまなデプロイシナリオの詳細なチュートリアルについては、ブログ[「Package and deploy classical ML models and LLMs easily with Amazon SageMaker AI – Part 2」](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-2-interactive-user-experiences-in-sagemaker-studio/)を参照してください。
### アーティファクトとアクセス許可を準備する
SageMaker Studio でモデルを作成する前に、このセクションを完了してください。
アーティファクトを Studio に取り入れてモデルを作成する場合、次の 2 つのオプションがあります:
1. モデルアーティファクト、カスタム推論コード、`requirements.txt` ファイルに記載されている依存関係を含めて `tar.gz` アーカイブにあらかじめパッケージ化できます。
1. SageMaker AI からアーティファクトをパッケージ化できます。未加工のモデルアーティファクトと依存関係を `requirements.txt` ファイルに取り込むだけで、SageMaker AI によってデフォルトの推論コードが提供されます (または、デフォルトのコードを独自のカスタム推論コードで上書きすることもできます)。PyTorch、XGBoost のフレームワークであれば、SageMaker AI でこのオプションを使用できます。
モデル、 AWS Identity and Access Management (IAM) ロール、Docker コンテナ (または SageMaker AI に構築済みのコンテナがある目的のフレームワークとバージョン) を持ち込むだけでなく、SageMaker AI Studio を介してモデルを作成およびデプロイするアクセス許可も付与する必要があります。
[AmazonSageMakerFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html) ポリシーを IAM ロールにアタッチし、SageMaker AI と他のサービスへのアクセスを可能にする必要があります。Studio でインスタンスタイプの料金を確認するには、[AWS PriceListServiceFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSPriceListServiceFullAccess.html) ポリシーもアタッチする必要があります (または、ポリシー全体をアタッチしない場合は、`pricing:GetProducts` アクションを使用します)。
モデルの作成時にモデルアーティファクトをアップロードする場合 (または推論レコメンデーションのサンプルペイロードファイルをアップロードする場合)、Amazon S3 バケットを作成する必要があります。バケット名には、 `SageMaker AI`という単語のプレフィックスを付ける必要があります。SageMaker AI では大文字小文字 (`Sagemaker` または `sagemaker`) は区別されません。
バケット命名規則 `sagemaker-{Region}-{accountID}` を使用することをお勧めします。このバケットは、アップロードしたアーティファクトを保存するために使用されます。
バケットを作成したら、次の CORS (クロスオリジンリソース共有) ポリシーをバケットにアタッチします。
```
[
{
"AllowedHeaders": ["*"],
"ExposeHeaders": ["Etag"],
"AllowedMethods": ["PUT", "POST"],
"AllowedOrigins": ['https://*.sagemaker.aws'],
}
]
```
次のいずれかの方法で、CORS ポリシーを Amazon S3 バケットにアタッチします。
+ Amazon S3 コンソールの[クロスオリジンリソース共有 (CORS) の編集](https://s3.console.aws.amazon.com/s3/bucket/bucket-name/property/cors/edit)ページに移動する
+ Amazon S3 API の [PutBucketCors](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketCors.html) を使用する。
+ put-bucket-cors AWS CLI コマンドを使用します。
```
aws s3api put-bucket-cors --bucket="..." --cors-configuration="..."
```
### デプロイモデルを作成する
この手順では、アーティファクトおよびその他の項目 (コンテナとフレームワーク、カスタム推論コード、ネットワーク設定など) を SageMaker AI で入力して、モデルのデプロイ可能なバージョンを作成します。
SageMaker Studio でデプロイ可能なモデルを作成するには、次の手順を実行します。
1. SageMaker Studio アプリケーションを開きます。
1. 左のナビゲーションペインで **[モデル]** を選択します。
1. **[デプロイ可能なモデル]** タブを選択します。
1. **デプロイ可能なモデル**ページで **[作成]** を選択します。
1. **デプロイ可能なモデルの作成**ページの **[モデル名]** フィールドに、モデルの名前を入力します。
**デプロイ可能なモデルの作成**ページで入力するセクションは、他にもいくつかあります。
**[コンテナ定義]** セクションは次のスクリーンショットのようになります。
![\[Studio でモデルを作成する際の [コンテナ定義] セクションのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/studio-container-definition.png)
****[コンテナ定義]** セクションで以下を実行します。**
1. **[コンテナタイプ]** では、SageMaker AI マネージドコンテナを使用する場合は **[構築済みコンテナ]** を選択し、独自のコンテナを使用する場合は **[独自のコンテナ**] を選択します。
1. **[構築済みコンテナ]** を選択した場合、使用する **[コンテナフレームワーク]**、**[フレームワークバージョン]**、および **[ハードウェアタイプ]** を選択します。
1. **[独自のコンテナ]** を選択した場合は、**[コンテナイメージへの ECR パス]** にAmazon ECR パスを入力します。
次に、**[アーティファクト]**セクションを次のスクリーンショットのように入力します。
![\[Studio でモデルを作成する [アーティファクト] セクションのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/studio-artifacts-section.png)
****[アーティファクト]** セクションでは、以下を実行します。**
1. SageMaker AI でモデルアーティファクト (PyTorch または XGBoost) をパッケージ化できるフレームワークを使用している場合は、**[アーティファクト]** で **[アーティファクトをアップロード]** オプションを選択します。このオプションを使用すると、未加工のモデルアーティファクト、カスタム推論コード、および requirements.txt ファイルを指定するだけで、SageMaker AI によってアーカイブのパッケージ化が処理されます。以下の操作を実行します。
1. **[アーティファクト]** で、**[アーティファクトのアップロード]** を選択して処理を続行します。または、`tar.gz` アーカイブにモデルファイル、推論コード、`requirements.txt` ファイルが含まれる場合は、**[S3 の URI を事前パッケージ化アーティファクトに入力する]** を選択します。
1. アーティファクトのアップロードを選択した場合は、**[S3 バケット]** に、SageMaker AI がアーティファクトをパッケージ化した後にそれを保存する Amazon S3 のバケットへのパスを入力します。以下の手順を実行します。
1. **[モデルアーティファクトをアップロード]** でモデルファイルをアップロードします。
1. SageMaker AI が推論のために提供するデフォルトコードを使用する場合は、**[推論コード]** で **[デフォルトの推論コードを使用]** を選択します。独自の推論コードを使用する場合は、**[カスタマイズした推論コードをアップロード]** を選択します。
1. **[requirements.txt をアップロード]** で、実行時にインストールする依存関係のリストが入力されたテキストファイルをアップロードします。
1. SageMaker AI でモデルアーティファクトをパッケージ化できるフレームワークを使用しない場合は、Studio に **[事前パッケージ化アーティファクト]** オプションが表示され、`tar.gz` アーカイブにパッケージ化されたすべてのアーティファクトを入力する必要があります。以下の操作を実行します。
1. **[事前パッケージ化アーティファクト]** で、`tar.gz` アーカイブが Amazon S3 に既にアップロードされている場合は、**[S3 の URI を事前パッケージ化モデルアーティファクトに入力する]** を選択します。アーカイブを SageMaker AI に直接アップロードする場合は、**[事前パッケージ化モデルアーティファクトをアップロード]** を選択します。
1. **[S3 の URI を事前パッケージ化モデルアーティファクトに入力する]**を選択した場合は、Amazon S3 のアーカイブへのパスを **S3 URI** に入力します。または、ローカルマシンからアーカイブを選択してアップロードします。
次のセクションは **[セキュリティ]** です。次のスクリーンショットのように表示されます。
![\[Studio でモデルを作成する [セキュリティ] セクションのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/studio-security-section.png)
****[セキュリティ]** セクションで、以下の操作を行います。**
1. **[IAM ロール]**に、IAM ロールの ARN を入力します。
1. (オプション) **[仮想プライベートクラウド (VPC)]** で、モデル設定とアーティファクトを保存する Amazon VPC を選択します。
1. (オプション) コンテナのインターネットアクセスを制限する場合は、**[ネットワークの隔離]** トグルをオンにします。
最後に、オプションで **[詳細オプション]** セクションに入力します。次のスクリーンショットのように表示されます。
![\[Studio でモデルを作成する [詳細オプション] セクションのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/studio-advanced-options.png)
**(オプション) **[詳細オプション]** セクションで、以下の操作を行います:**
1. 作成されたモデルで Amazon SageMaker Inference Recommender ジョブを実行する場合は、**[カスタマイズされたインスタンスのレコメンデーション]** トグルをオンにします。Inference Recommender は、推論のパフォーマンスとコストを最適化できるインスタンスタイプを推奨するための機能です。これらのインスタンスのレコメンデーションは、モデルのデプロイを準備する際に表示されます。
1. **[環境変数を追加]** には、コンテナの環境変数をキーと値のペアで入力します。
1. **[タグ]** に任意のタグをキーと値のペアで入力します。
1. モデルとコンテナの設定が完了したら、**[デプロイ可能なモデルを作成]** を選択します。
これで、SageMaker Studio にデプロイ可能なモデルが完成しました。
### モデルをデプロイする
最後に、前の手順で設定したモデルを HTTPS エンドポイントにデプロイします。エンドポイントに 1 つまたは複数のモデルをデプロイできます。
**モデルとエンドポイントの互換性**
モデルをエンドポイントにデプロイする前に、以下の設定がモデルとエンドポイント間で同じであり、互換性が保たれていることを確認してください。
IAM ロール
Amazon VPC (サブネットとセキュリティグループ)
ネットワークの隔離 (有効または無効)
互換性のないエンドポイントにモデルがデプロイされないよう、Studio で次の処理が行われます。
新しいエンドポイントにモデルをデプロイすると、SageMaker AI は互換性を維持するようにエンドポイントを設定します。この設定を変更して互換性が失われると、Studio はアラートを表示し、デプロイが失敗します。
既存のエンドポイントにデプロイすると、エンドポイントに互換性がない場合は Studio がアラートを表示し、デプロイが失敗します。
デプロイに複数のモデルを追加する場合、相互に互換性がなければ、Studio によってモデルのデプロイがエラーになります。
Studio にモデルとエンドポイントの非互換性に関するアラートが表示された場合、**[詳細を表示]** を選択して、どの設定で互換性が失われたかを確認できます。
モデルをデプロイするために、Studio で以下を実行する方法を選択できます。
1. SageMaker Studio アプリケーションを開きます。
1. 左のナビゲーションペインで **[モデル]** を選択します。
1. **[モデル]** ページで、SageMaker AI モデルのリストから 1 つ以上のモデルを選択します。
1. **[デプロイ]** をクリックします。
1. **[エンドポイント名]** で、ドロップダウンメニューを開きます。既存のエンドポイントを選択するか、モデルをデプロイする新しいエンドポイントを作成します。
1. **[インスタンスタイプ]** で、エンドポイントに使用するインスタンスタイプを選択します。モデルに対して以前に Inference Recommender ジョブを実行している場合は、推奨されるインスタンスタイプが **[推奨]** というタイトルのリストに表示されます。実行していない場合は、モデルに適した **[想定インスタンス]** がいくつか表示されます。
**JumpStart のインスタンスタイプの互換性**
JumpStart モデルをデプロイする場合、Studio にはモデルがサポートするインスタンスタイプのみが表示されます。
1. **[初期インスタンス数]** には、エンドポイントにプロビジョニングするインスタンスの初期数を入力します。
1. **[最大インスタンス数]** には、トラフィックの増加に合わせてスケールアップする場合にエンドポイントにプロビジョニング可能なインスタンスの最大数を指定します。
1. デプロイするモデルがモデルハブで最も使用されている JumpStart LLM のいずれかである場合は、**[代替設定]** オプションが [インスタンスタイプ] と [インスタンス数] フィールドの後に表示されます。
最も一般的な JumpStart LLMs AWS の場合、 には、コストまたはパフォーマンスを最適化するためのベンチマーク済みのインスタンスタイプがあります。このデータを使用し、どのインスタンスタイプを LLM のデプロイに使用するかを判断できます。**[代替設定]** を選択して、ベンチマーク済みのデータを表示するダイアログボックスを開きます。パネルは次のスクリーンショットのようになります。
![\[[代替設定] ボックスのスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/studio-jumpstart-alternate-configurations.png)
**[代替設定]** ボックスで以下の操作を行います。
1. インスタンスのタイプを選択します。**[1 時間あたりのコスト]** または **[最高のパフォーマンス]** を選択して、モデルのコストやパフォーマンスを最適化するインスタンスを表示します。**[その他のサポートされているインスタンス]** を選択して、JumpStart モデルと互換性のある他のインスタンスタイプのリストを表示することもできます。ここでインスタンスタイプを選択すると、手順 6 で指定したインスタンスが上書きされることに注意してください。
1. (任意) **[選択した設定をカスタマイズ]** トグルをオンにして、**[トークン合計の最大数]** (許可するトークンの最大数。入力トークンおよびモデルで生成されるトークンの合計)、**[入力するトークンの最大長]** (各リクエストで入力が許可されるトークンの最大数)、および **[最大同時リクエスト]** (モデルが一度に処理できるリクエストの最大数) を指定します。
1. **[選択]** を選択して、インスタンスタイプと設定を確認します。
1. **[モデル]** フィールドには、デプロイするモデルの名前がすでに入力されています。**[モデルの追加]** を選択して、デプロイにモデルを追加します。追加するモデルごとに、次のフィールドを入力します:
1. **[CPU コアの数]** に、モデルのみで使用される CPU コアを入力します。
1. **[最小コピー数]** には、任意の時点でエンドポイントでホストされるモデルコピーの最小数を入力します。
1. **[最小 CPU メモリ (MB)]** には、モデルに必要な最小メモリ量 (MB) を入力します。
1. **[最大 CPU メモリ (MB)]** には、モデルに使用を許可するメモリの最大量 (MB) を入力します。
1. (オプション) **[詳細オプション]** で、以下の操作を行います:
1. **[IAM ロール]** で、デフォルトの SageMaker AI IAM 実行ロールを使用するか、必要なアクセス許可を含む独自のロールを指定します。この IAM ロールは、デプロイ可能なモデルの作成時に指定したロールと同じである必要があります。
1. **[仮想プライベートクラウド (VPC)]** では、エンドポイントをホストする VPC を指定します。
1. **暗号化 KMS キー**で、 AWS KMS キーを選択して、エンドポイントをホストする ML コンピューティングインスタンスにアタッチされたストレージボリューム上のデータを暗号化します。
1. **[ネットワーク分離の有効化]** トグルをオンにして、コンテナのインターネットアクセスを制限します。
1. **[タイムアウト設定]** で、**[モデルデータのダウンロードタイムアウト (秒)]** と **[コンテナ起動のヘルスチェックタイムアウト (秒)]** フィールドに値を入力します。これらの値によって、SageMaker AI がモデルをコンテナにダウンロードする最大時間と、コンテナを起動する最大時間が決まります。
1. **[タグ]** に任意のタグをキーと値のペアで入力します。
**注記**
SageMaker AI は、IAM ロール、VPC、およびネットワーク隔離の設定を、デプロイするモデルと互換性のある初期値を使用して設定します。この設定を変更して互換性が失われると、Studio はアラートを表示し、デプロイが失敗します。
オプションを設定すると、ページが次のスクリーンショットのように表示されます。
![\[Studio のデプロイモデルページのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/studio-deploy-realtime-model-2.png)
デプロイを設定したら、**[デプロイ]** を選択してエンドポイントを作成し、モデルをデプロイします。
## Python SDK でモデルをデプロイする
SageMaker Python SDK を使用すると、2 つの方法でモデルを構築できます。1 つ目は、`Model` クラスまたは `ModelBuilder` クラスからモデルオブジェクトを作成する方法です。`Model` クラスを使用して `Model` オブジェクトを作成する場合は、モデルパッケージまたは推論コード (モデルサーバーによって異なります) を指定し、クライアントとサーバー間のデータのシリアル化と逆シリアル化を処理するスクリプトと、Amazon S3 にアップロードされる依存関係を指定する必要があります。2 つ目は、`ModelBuilder` を使用してモデルアーティファクトまたは推論コードを提供する方法です。`ModelBuilder` は依存関係を自動的に取得し、必要なシリアル化およびシリアル化解除関数を推論し、依存関係をパッケージ化して `Model` オブジェクトを作成します。`ModelBuilder` の詳細については、「[ModelBuilder を使用して Amazon SageMaker AI でモデルを作成する](how-it-works-modelbuilder-creation.md)」を参照してください。
次のセクションでは、モデルを作成する方法と、モデルオブジェクトをデプロイする方法を説明します。
### セットアップする
以下に、モデルデプロイプロセスを準備する例を示します。必要なライブラリをインポートし、モデルアーティファクトを指す S3 URL を定義します。
------
#### [ SageMaker Python SDK ]
**Example import ステートメント**
次の例は、SageMaker Python SDK、SDK for Python (Boto3)、および Python 標準ライブラリからモジュールをインポートします。これらのモジュールはモデルのデプロイ便利であり、以下の例でも使用されています。
```
import boto3
from datetime import datetime
from sagemaker.compute_resource_requirements.resource_requirements import ResourceRequirements
from sagemaker.predictor import Predictor
from sagemaker.enums import EndpointType
from sagemaker.model import Model
from sagemaker.session import Session
```
------
#### [ boto3 inference components ]
**Example import ステートメント**
次の例は、SDK for Python (Boto3) と Python 標準ライブラリからモジュールをインポートします。これらのモジュールはモデルのデプロイ便利であり、以下の例でも使用されています。
```
import boto3
import botocore
import sys
import time
```
------
#### [ boto3 models (without inference components) ]
**Example import ステートメント**
次の例は、SDK for Python (Boto3) と Python 標準ライブラリからモジュールをインポートします。これらのモジュールはモデルのデプロイ便利であり、以下の例でも使用されています。
```
import boto3
import botocore
import datetime
from time import gmtime, strftime
```
------
**Example モデルアーティファクト URL**
次のコードは、Amazon S3 URL を構築する例です。URL は、Amazon S3 バケット内の事前トレーニング済みモデルのモデルアーティファクトを指します。
```
# Create a variable w/ the model S3 URL
# The name of your S3 bucket:
s3_bucket = "amzn-s3-demo-bucket"
# The directory within your S3 bucket your model is stored in:
bucket_prefix = "sagemaker/model/path"
# The file name of your model artifact:
model_filename = "my-model-artifact.tar.gz"
# Relative S3 path:
model_s3_key = f"{bucket_prefix}/"+model_filename
# Combine bucket name, model file name, and relate S3 path to create S3 model URL:
model_url = f"s3://{s3_bucket}/{model_s3_key}"
```
完全な Amazon S3 URL が変数 `model_url` に保存され、次の例で使用されます。
### 概要:
SageMaker Python SDK または SDK for Python (Boto3) を使用してモデルをデプロイする方法は複数あります。以下のセクションでは、いくつかのアプローチで実行する手順をまとめて説明します。それらの手順を、以下の例で示しています。
------
#### [ SageMaker Python SDK ]
SageMaker Python SDK を使用すると、次のいずれかの方法でモデルを構築できます:
+ **`Model` クラスからモデルオブジェクトを作成する** – モデルパッケージまたは推論コード (モデルサーバーによって異なります) を指定し、クライアントとサーバー間のデータのシリアル化と逆シリアル化を処理するスクリプトと、Amazon S3 にアップロードされる依存関係を指定する必要があります。
+ **`ModelBuilder` クラスからモデルオブジェクトを作成する** – モデルアーティファクトまたは推論コードを指定すると、`ModelBuilder` が依存関係を自動的にキャプチャし、必要なシリアル化およびシリアル化解除関数を推測して、依存関係をパッケージ化した `Model` オブジェクトを作成します。
`ModelBuilder` の詳細については、「[ModelBuilder を使用して Amazon SageMaker AI でモデルを作成する](how-it-works-modelbuilder-creation.md)」を参照してください。詳細については、ブログ[「Package and deploy classical ML models and LLMs easily with SageMaker AI – Part 1」](https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-1-pysdk-improvements/)をご覧ください。
以下の例では、モデルを作成する方法と、モデルオブジェクトをデプロイする方法を説明します。これらの方法でモデルをデプロイするには、次の手順を実行します。
1. モデルに割り当てるエンドポイントリソースを、`ResourceRequirements` オブジェクトを使用して定義します。
1. `Model` クラスまたは `ModelBuilder` クラスからモデルオブジェクトを作成します。`ResourceRequirements` オブジェクトはモデル設定で指定します。
1. `Model` オブジェクトの `deploy` メソッドを使用して、モデルをエンドポイントにデプロイします。
------
#### [ boto3 inference components ]
次の例は、モデルを推論コンポーネントに割り当てた後、推論コンポーネントをエンドポイントにデプロイする方法を示しています。この方法でモデルをデプロイするには、次の手順を実行します:
1. (オプション) [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html) メソッドを使用して SageMaker AI モデルオブジェクトを作成します。
1. エンドポイント設定オブジェクトを作成して、エンドポイントの設定を指定します。[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config) メソッドを使用して作成します。
1. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) メソッドを使用してエンドポイントを作成し、作成したエンドポイント設定をリクエストに指定します。
1. `create_inference_component` メソッドを使用して推論コンポーネントを作成します。設定で、次のいずれかを実行してモデルを指定します。
+ SageMaker AI モデルオブジェクトを指定する
+ モデルイメージ URI と S3 URL を指定する
また、エンドポイントリソースをモデルに割り当てます。推論コンポーネントを作成することで、モデルがエンドポイントにデプロイされます。モデルごとに 1 つずつ、複数の推論コンポーネントを作成することで、複数のモデルをエンドポイントにデプロイできます。
------
#### [ boto3 models (without inference components) ]
次の例は、モデルオブジェクトを作成し、モデルをエンドポイントにデプロイする方法を示しています。この方法でモデルをデプロイするには、次の手順を実行します:
1. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html) メソッドを使用して SageMaker AI モデルを作成します。
1. エンドポイント設定オブジェクトを作成して、エンドポイントの設定を指定します。[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#create-endpoint-config) メソッドを使用して作成します。エンドポイント設定で、モデルオブジェクトを本番稼働用のバリアントに割り当てます。
1. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) メソッドを使用してエンドポイントを作成します。作成したエンドポイント設定をリクエストに指定します。
エンドポイントを作成すると、SageMaker AI はエンドポイントリソースをプロビジョニングし、モデルをエンドポイントにデプロイします。
------
### 構成する
次の例では、モデルをエンドポイントにデプロイするために必要なリソースを設定します。
------
#### [ SageMaker Python SDK ]
次の例は、`ResourceRequirements` オブジェクトを持つモデルにエンドポイントリソースを割り当てています。これらのリソースには、CPU コア、アクセラレーター、メモリが含まれます。次に、この例のように `Model` クラスからモデルオブジェクトを作成します。または、[ModelBuilder](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-modelbuilder-creation.html) クラスをインスタンス化して `build` を実行することで、モデルオブジェクトを作成することもできます。このメソッドも例に示されています。`ModelBuilder` はモデルをパッケージ化する統合インターフェイスを提供し、このインスタンスでは大規模にデプロイするためのモデルを準備しています。この例は、`ModelBuilder` を使用して Hugging Face モデルをコンストラクトします。(JumpStart モデルを渡すこともできます)。モデルを構築したら、モデルオブジェクトでリソース要件を指定します。次の手順では、このオブジェクトを使用してモデルをエンドポイントにデプロイします。
```
resources = ResourceRequirements(
requests = {
"num_cpus": 2, # Number of CPU cores required:
"num_accelerators": 1, # Number of accelerators required
"memory": 8192, # Minimum memory required in Mb (required)
"copies": 1,
},
limits = {},
)
now = datetime.now()
dt_string = now.strftime("%d-%m-%Y-%H-%M-%S")
model_name = "my-sm-model"+dt_string
# build your model with Model class
model = Model(
name = "model-name",
image_uri = "image-uri",
model_data = model_url,
role = "arn:aws:iam::111122223333:role/service-role/role-name",
resources = resources,
predictor_cls = Predictor,
)
# Alternate mechanism using ModelBuilder
# uncomment the following section to use ModelBuilder
/*
model_builder = ModelBuilder(
model="", # like "meta-llama/Llama-2-7b-hf"
schema_builder=SchemaBuilder(sample_input,sample_output),
env_vars={ "HUGGING_FACE_HUB_TOKEN": "}" }
)
# build your Model object
model = model_builder.build()
# create a unique name from string 'mb-inference-component'
model.model_name = unique_name_from_base("mb-inference-component")
# assign resources to your model
model.resources = resources
*/
```
------
#### [ boto3 inference components ]
次の例は、`create_endpoint_config` メソッドを使用してエンドポイントを設定しています。この設定を、エンドポイントの作成時に割り当てます。設定で、1 つ以上の本番稼働用バリアントを定義します。バリアントごとに、Amazon SageMaker AI がプロビジョニングするインスタンスタイプを選択し、マネージドインスタンススケーリングを有効化できます。
```
endpoint_config_name = "endpoint-config-name"
endpoint_name = "endpoint-name"
inference_component_name = "inference-component-name"
variant_name = "variant-name"
sagemaker_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
ProductionVariants = [
{
"VariantName": variant_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1,
"ManagedInstanceScaling": {
"Status": "ENABLED",
"MinInstanceCount": 1,
"MaxInstanceCount": 2,
},
}
],
)
```
------
#### [ boto3 models (without inference components) ]
**Example モデルの定義**
次の例では、 AWS SDK for Python (Boto3)で `create_model`メソッドを使用して SageMaker AI モデルを定義します。
```
model_name = "model-name"
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = "arn:aws:iam::111122223333:role/service-role/role-name",
PrimaryContainer = {
"Image": "image-uri",
"ModelDataUrl": model_url,
}
)
```
この例では以下を指定します:
+ `ModelName`: モデルの名前 (この例では、`model_name` という文字列変数として保存されています)。
+ `ExecutionRoleArn`: Amazon SageMaker AI が機械学習コンピューティングインスタンスへのデプロイまたはバッチ変換ジョブのためにモデルアーティファクトや Docker イメージにアクセスするのに使用できる IAM ロールの Amazon リソースネーム (ARN)。
+ `PrimaryContainer`: 推論コード、関連アーティファクト、予測のためにモデルがデプロイされるときに推論コードが使用するカスタム環境マップを含むプライマリ Docker イメージの場所。
**Example エンドポイント設定**
次の例は、`create_endpoint_config` メソッドを使用してエンドポイントを設定しています。Amazon SageMaker AI はこの設定を使用してモデルをデプロイします。この設定では、`create_model` メソッドを使用して作成された 1 つ以上のモデルを特定して、Amazon SageMaker AI がプロビジョンするリソースをデプロイします。
```
endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName = "endpoint-config-name",
# List of ProductionVariant objects, one for each model that you want to host at this endpoint:
ProductionVariants = [
{
"VariantName": "variant-name", # The name of the production variant.
"ModelName": model_name,
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
]
)
```
この例では、`ProductionVariants` フィールドに次のキーを指定します:
+ `VariantName`: 本番稼働用バリアントの名前。
+ `ModelName`: ホストするモデルの名前。これは、モデル作成時に指定した名前です。
+ `InstanceType`: コンピューティングインスタンスタイプ。サポートされているコンピューティングインスタンスタイプとインスタンスタイプごとの料金のリストについては、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html) の `InstanceType` フィールドと「[SageMaker AI Pricing](https://aws.amazon.com/sagemaker/pricing/)」を参照してください。
------
### デプロイ
次の例は、モデルをエンドポイントにデプロイしています。
------
#### [ SageMaker Python SDK ]
次の例は、モデルオブジェクトの `deploy` メソッドを使用して、モデルをリアルタイムの HTTPS エンドポイントにデプロイします。モデルの作成とデプロイの両方の `resources` 引数に値を指定する場合は、デプロイに指定するリソースが優先されます。
```
predictor = model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
resources = resources,
)
```
この例では `instance_type` フィールドにモデルの Amazon EC2 インスタンスタイプの名前を指定します。`initial_instance_count` フィールドには、エンドポイントで実行されるインスタンスの初期数を指定します。
次のコードサンプルは、モデルをエンドポイントにデプロイし、別のモデルを同じエンドポイントにデプロイする別のケースを示しています。この場合、両方のモデルの `deploy` メソッドに同じエンドポイント名を指定する必要があります。
```
# Deploy the model to inference-component-based endpoint
falcon_predictor = falcon_model.deploy(
initial_instance_count = 1,
instance_type = "ml.p4d.24xlarge",
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = ""
resources = resources,
)
# Deploy another model to the same inference-component-based endpoint
llama2_predictor = llama2_model.deploy( # resources already set inside llama2_model
endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED,
endpoint_name = "" # same endpoint name as for falcon model
)
```
------
#### [ boto3 inference components ]
エンドポイント設定が完了したら、[create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) メソッドを使用してエンドポイントを作成します。エンドポイント名は、アカウントの AWS リージョン AWS 内で一意である必要があります。
次の例では、リクエストで指定されたエンドポイント設定を使用してエンドポイントを作成しています。Amazon SageMaker AI は、エンドポイントを使用してリソースをプロビジョンします。
```
sagemaker_client.create_endpoint(
EndpointName = endpoint_name,
EndpointConfigName = endpoint_config_name,
)
```
エンドポイントを作成したら、推論コンポーネントを作成することで、エンドポイントに 1 つまたは複数のモデルをデプロイできます。次の例では、`create_inference_component` メソッドを使用して 1 つ作成しています。
```
sagemaker_client.create_inference_component(
InferenceComponentName = inference_component_name,
EndpointName = endpoint_name,
VariantName = variant_name,
Specification = {
"Container": {
"Image": "image-uri",
"ArtifactUrl": model_url,
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
},
RuntimeConfig = {"CopyCount": 2}
)
```
------
#### [ boto3 models (without inference components) ]
**Example トラブルシューティング**
SageMaker AI にエンドポイント設定を提供します。このサービスは、ML コンピューティングインスタンスを起動し、設定で指定された 1 つ以上のモデルをデプロイします。
モデルとエンドポイントの設定が完了したら、[create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html) メソッドを使用してエンドポイントを作成します。エンドポイント名は、アカウントの AWS リージョン AWS 内で一意である必要があります。
次の例では、リクエストで指定されたエンドポイント設定を使用してエンドポイントを作成しています。Amazon SageMaker AI は、エンドポイントを使用してリソースをプロビジョンし、モデルをデプロイします。
```
create_endpoint_response = sagemaker_client.create_endpoint(
# The endpoint name must be unique within an AWS Region in your AWS account:
EndpointName = "endpoint-name"
# The name of the endpoint configuration associated with this endpoint:
EndpointConfigName = "endpoint-config-name")
```
------
## を使用してモデルをデプロイする AWS CLI
を使用して、モデルをエンドポイントにデプロイできます AWS CLI。
### 概要:
を使用してモデルをデプロイする場合 AWS CLI、推論コンポーネントの有無にかかわらずデプロイできます。その両方のアプローチで実行するコマンドを、以下のセクションにまとめます。これらのコマンドは、以下の例で示されています。
------
#### [ With inference components ]
推論コンポーネントを使用してモデルをデプロイするには、以下を実行します。
1. (オプション) [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html) コマンドを使用してモデルを作成します。
1. エンドポイント設定を作成して、エンドポイントを設定します。作成するには、[https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html) コマンドを実行します。
1. [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html) コマンドを使用してエンドポイントを作成します。コマンド本文で、作成したエンドポイント設定を指定します。
1. `create-inference-component` コマンドを使用して推論コンポーネントを作成します。設定で、次のいずれかを実行してモデルを指定します。
+ SageMaker AI モデルオブジェクトを指定する
+ モデルイメージ URI と S3 URL を指定する
また、エンドポイントリソースをモデルに割り当てます。推論コンポーネントを作成することで、モデルがエンドポイントにデプロイされます。モデルごとに 1 つずつ、複数の推論コンポーネントを作成することで、複数のモデルをエンドポイントにデプロイできます。
------
#### [ Without inference components ]
推論コンポーネントを使用せずにモデルをデプロイするには、以下を実行します。
1. [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html) コマンドを使用して SageMaker AI モデルを作成します。
1. エンドポイント設定オブジェクトを作成して、エンドポイントの設定を指定します。作成するには、[https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html) コマンドを使用します。エンドポイント設定で、モデルオブジェクトを本番稼働用のバリアントに割り当てます。
1. [https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html) コマンドを使用してエンドポイントを作成します。コマンド本文で、作成したエンドポイント設定を指定します。
エンドポイントを作成すると、SageMaker AI はエンドポイントリソースをプロビジョニングし、モデルをエンドポイントにデプロイします。
------
### 構成する
次の例では、モデルをエンドポイントにデプロイするために必要なリソースを設定します。
------
#### [ With inference components ]
**Example create-endpoint-config コマンド**
以下の例は、[create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html) コマンドを使用してエンドポイント設定を作成します。
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name\
--production-variants file://production-variants.json
```
この例で、次の JSON を使用して本番稼働用バリアントを `production-variants.json` ファイルに定義します。
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
コマンドが成功すると、 は作成したリソースの ARN で AWS CLI 応答します。
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
#### [ Without inference components ]
**Example create-model コマンド**
次の例では、[create-model](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-model.html) コマンドを使用してモデルを作成します。
```
aws sagemaker create-model \
--model-name model-name \
--execution-role-arn arn:aws:iam::111122223333:role/service-role/role-name \
--primary-container "{ \"Image\": \"image-uri\", \"ModelDataUrl\": \"model-s3-url\"}"
```
コマンドが成功すると、 は作成したリソースの ARN で AWS CLI 応答します。
```
{
"ModelArn": "arn:aws:sagemaker:us-west-2:111122223333:model/model-name"
}
```
**Example create-endpoint-config コマンド**
以下の例は、[create-endpoint-config](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint-config.html) コマンドを使用してエンドポイント設定を作成します。
```
aws sagemaker create-endpoint-config \
--endpoint-config-name endpoint-config-name \
--production-variants file://production-variants.json
```
この例で、次の JSON を使用して本番稼働用バリアントを `production-variants.json` ファイルに定義します。
```
[
{
"VariantName": "variant-name",
"ModelName": "model-name",
"InstanceType": "ml.p4d.24xlarge",
"InitialInstanceCount": 1
}
]
```
コマンドが成功すると、 は作成したリソースの ARN で AWS CLI 応答します。
```
{
"EndpointConfigArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint-config/endpoint-config-name"
}
```
------
### デプロイ
次の例は、モデルをエンドポイントにデプロイしています。
------
#### [ With inference components ]
**Example create-endpoint コマンド**
次の例は、[create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html) コマンドを使用してエンドポイントを作成します。
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
コマンドが成功すると、 は作成したリソースの ARN で AWS CLI 応答します。
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
**Example create-inference-component コマンド**
次の例は、create-inference-component コマンドを使用して推論コンポーネントを作成します。
```
aws sagemaker create-inference-component \
--inference-component-name inference-component-name \
--endpoint-name endpoint-name \
--variant-name variant-name \
--specification file://specification.json \
--runtime-config "{\"CopyCount\": 2}"
```
この例では、コンテナと演算処理リソースが、次の JSON を使用して `specification.json` ファイルに定義されています。
```
{
"Container": {
"Image": "image-uri",
"ArtifactUrl": "model-s3-url"
},
"ComputeResourceRequirements": {
"NumberOfCpuCoresRequired": 1,
"MinMemoryRequiredInMb": 1024
}
}
```
コマンドが成功すると、 は作成したリソースの ARN で AWS CLI 応答します。
```
{
"InferenceComponentArn": "arn:aws:sagemaker:us-west-2:111122223333:inference-component/inference-component-name"
}
```
------
#### [ Without inference components ]
**Example create-endpoint コマンド**
次の例は、[create-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/create-endpoint.html) コマンドを使用してエンドポイントを作成します。
```
aws sagemaker create-endpoint \
--endpoint-name endpoint-name \
--endpoint-config-name endpoint-config-name
```
コマンドが成功すると、 は作成したリソースの ARN で AWS CLI 応答します。
```
{
"EndpointArn": "arn:aws:sagemaker:us-west-2:111122223333:endpoint/endpoint-name"
}
```
------
# リアルタイム推論用のモデルを呼び出す
Amazon SageMaker AI を使用してモデルをエンドポイントにデプロイしたら、そこに推論リクエストを送信してモデルと対話できます。モデルに推論リクエストを送信するには、それをホストするエンドポイントを呼び出します。Amazon SageMaker Studio、 AWS SDK、または AWS CLIを使って、エンドポイントを呼び出します。
## Amazon SageMaker Studio を使ってモデルを呼び出す
モデルをエンドポイントにデプロイした後、Amazon SageMaker Studio を使用してエンドポイントを表示し、単一の推論リクエストを送信することでエンドポイントをテストできます。
**注記**
SageMaker AI はリアルタイムエンドポイントに対するエンドポイントテストのみを Studio でサポートしています。
**エンドポイントにテスト推論リクエストを送信するには**
1. Amazon SageMaker Studio を起動します。
1. 左側のナビゲーションペインで、**[デプロイ]** を選択します。
1. ドロップダウンから **[Endpoints]** (エンドポイント) を選択します。
1. エンドポイントを名前で検索し、表から名前を選択します。**[エンドポイント]** パネルに一覧表示されているエンドポイント名は、モデルをデプロイするときに定義されます。Studio ワークスペースで、**[エンドポイント]** ページが新しいタブに開きます。
1. **[推論のテスト]** タブを選択します。
1. **[テストオプション]** で、次のいずれかのオプションを選択します。
1. **[サンプルリクエストをテストする]** を選択すると、エンドポイントにリクエストがすぐに送信されます。**[JSON エディタ]** を使用してサンプルデータを JSON 形式で送信し、**[リクエストの送信]** を選択してリクエストをエンドポイントに送信します。リクエストを送信すると、Studio の JSON エディタの右側のカードに推論の出力が表示されます。
1. **[Python SDK サンプルコードを使用する]** を選択すると、エンドポイントにリクエストを送信するためのコードが表示されます。そのコードを **[推論リクエストの例]** セクションからコピーし、テスト環境で実行します。
カード上部に、エンドポイントに送信されたリクエストのタイプが表示されます (現在は JSON のみが受け入れられます)。カードには次のフィールドが表示されます。
+ **ステータス** – 次のいずれかのステータスタイプが表示されます。
+ `Success` – 成功したリクエスト。
+ `Failed` – 失敗したリクエスト。**[失敗の理由]** の下にレスポンスが表示されます。
+ `Pending` – 推論リクエストの保留中は、ステータスに回転する円形のアイコンが表示されます。
+ **実行時間** – 呼び出しにかかった時間 (終了時刻から開始時刻を引いた時間) をミリ秒単位で表します。
+ **リクエスト時間**: リクエストが送信されてから何分経過したか。
+ **結果時間**: 結果が返されてから何分経過したか。
## を使用してモデルを呼び出す AWS SDK for Python (Boto3)
アプリケーションコードでモデルエンドポイントを呼び出す場合は、 を含むいずれかの AWS SDKs を使用できます AWS SDK for Python (Boto3)。この SDK を使用してエンドポイントを呼び出すには、次のいずれかの Python メソッドを使用します。
+ `invoke_endpoint` – モデルエンドポイントに推論リクエストを送信し、モデルが生成したレスポンスを返します。
このメソッドは、モデルが生成を完了した後、推論ペイロードを 1 つのレスポンスとして返します。詳細については、「*AWS SDK for Python (Boto3) API リファレンス*」の「[invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html)」を参照してください。
+ `invoke_endpoint_with_response_stream` - モデルエンドポイントに推論リクエストを送信し、モデルが推論を生成している間、レスポンスを順番にストリーミングします。
このメソッドを使用すると、アプリケーションはレスポンスの一部が使用可能になるとすぐに受信します。詳細については、「*AWS SDK for Python (Boto3) API リファレンス*」の「[invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html)」を参照してください。
このメソッドは、推論ストリーミングをサポートするモデルを呼び出す場合にのみ使用してください。
これらのメソッドをアプリケーションコードで使用する前に、SageMaker AI ランタイムクライアントを起動し、エンドポイントの名前を指定する必要があります。次の例で、残りの例のクライアントとエンドポイントを設定します。
```
import boto3
sagemaker_runtime = boto3.client(
"sagemaker-runtime", region_name='aws_region')
endpoint_name='endpoint-name'
```
### 推論レスポンスを取得するために呼び出す
次の例では、`invoke_endpoint` メソッドを使用し、 AWS SDK for Python (Boto3)でエンドポイントを呼び出します。
```
# Gets inference from the model hosted at the specified endpoint:
response = sagemaker_runtime.invoke_endpoint(
EndpointName=endpoint_name,
Body=bytes('{"features": ["This is great!"]}', 'utf-8')
)
# Decodes and prints the response body:
print(response['Body'].read().decode('utf-8'))
```
この例では、SageMaker AI への入力データを `Body` フィールドで指定し、モデルに渡しています。このデータは、トレーニングに使われたのと同じ形式である必要があります。例では、レスポンスを `response` 変数に割り当てています。
`response` 変数は、HTTP ステータス、デプロイされたモデルの名前、および他のフィールドへのアクセスを提供します。次のスニペットは HTTP ステータスコードを出力します:
```
print(response["HTTPStatusCode"])
```
### 推論レスポンスをストリーミングするために呼び出す
推論ストリーミングをサポートするモデルをデプロイした場合、そのモデルを呼び出して、その推論ペイロードをパートのストリームとして受け取ることができます。モデルがこれらのパートを生成すると、段階的に配信されます。推論ストリームを受信する場合、アプリケーションはモデルがレスポンスペイロード全体を生成するのを待つ必要はありません。代わりに、アプリケーションはレスポンスの一部が使用可能になるとすぐに受信します。
アプリケーションで推論ストリームを使用することで、ユーザーは最初のパートをすぐに取得できるので、推論が速いと認識できるインタラクションを作成できます。ストリーミングを実装し、チャットボット、仮想アシスタント、ミュージックジェネレーターなどの高速でインタラクティブな体験をサポートできます。例えば、大規模言語モデル (LLM) が生成するテキストを段階的に表示するチャットボットを作成できます。
推論ストリームを取得するには、`invoke_endpoint_with_response_stream` メソッドを使用します。レスポンスの本文で、SDK は推論を一連の `PayloadPart` オブジェクトとして出力する `EventStream` オブジェクトを提供します。
**Example 推論ストリーム**
`PayloadPart` オブジェクトのストリームの例を次に示します。
```
{'PayloadPart': {'Bytes': b'{"outputs": [" a"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" challenging"]}\n'}}
{'PayloadPart': {'Bytes': b'{"outputs": [" problem"]}\n'}}
. . .
```
各ペイロード部分において、`Bytes` フィールドがモデルからの推論レスポンスの一部を提供します。この部分は、テキスト、イメージ、オーディオデータなど、モデルが生成するどのコンテンツタイプにもなります。この例では、LLM から生成されたテキストを含む JSON オブジェクトです。
通常、ペイロード部分にはモデルからの個別のデータチャンクが含まれます。この例では、個別のチャンクは JSON オブジェクト全体です。ストリーミングレスポンスは、チャンクを複数のペイロード部分に分割したり、複数のチャンクを 1 つのペイロードパートに組み合わせたりすることがあります。次の例は、2 つのペイロードパートに分割された JSON 形式のデータチャンクを示しています。
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
推論ストリームを処理するアプリケーションコードを記述するときは、このような時折発生するデータの分割や組み合わせを処理するロジックを含めてください。1 つの方法として、アプリケーションがペイロードパートを受け取る間、`Bytes` のコンテンツを連結するコードを記述することができます。ここで例の JSON データを連結することで、データを改行で区切られた JSON 本文に結合できます。その後、コードで各行の JSON オブジェクト全体を解析してストリームを処理できます。
次の例は、例の `Bytes` のコンテンツを連結したときに作成される、改行で区切られた JSON です。
```
{"outputs": [" a"]}
{"outputs": [" challenging"]}
{"outputs": [" problem"]}
. . .
```
**Example 推論ストリームを処理するコード**
次の Python クラス `SmrInferenceStream` の例は、JSON 形式でテキストデータを送信する推論ストリームを処理する方法を示しています。
```
import io
import json
# Example class that processes an inference stream:
class SmrInferenceStream:
def __init__(self, sagemaker_runtime, endpoint_name):
self.sagemaker_runtime = sagemaker_runtime
self.endpoint_name = endpoint_name
# A buffered I/O stream to combine the payload parts:
self.buff = io.BytesIO()
self.read_pos = 0
def stream_inference(self, request_body):
# Gets a streaming inference response
# from the specified model endpoint:
response = self.sagemaker_runtime\
.invoke_endpoint_with_response_stream(
EndpointName=self.endpoint_name,
Body=json.dumps(request_body),
ContentType="application/json"
)
# Gets the EventStream object returned by the SDK:
event_stream = response['Body']
for event in event_stream:
# Passes the contents of each payload part
# to be concatenated:
self._write(event['PayloadPart']['Bytes'])
# Iterates over lines to parse whole JSON objects:
for line in self._readlines():
resp = json.loads(line)
part = resp.get("outputs")[0]
# Returns parts incrementally:
yield part
# Writes to the buffer to concatenate the contents of the parts:
def _write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
# The JSON objects in buffer end with '\n'.
# This method reads lines to yield a series of JSON objects:
def _readlines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
self.read_pos += len(line)
yield line[:-1]
```
この例では、次のように推論ストリームを処理します。
+ SageMaker AI ランタイムクライアントを初期化し、モデルエンドポイントの名前を設定します。推論ストリームを取得する前に、エンドポイントがホストするモデルは推論ストリーミングをサポートしている必要があります。
+ 例の `stream_inference` メソッドでリクエスト本文を受け取り、SDK の `invoke_endpoint_with_response_stream` メソッドに渡します。
+ SDK が返す `EventStream` オブジェクト内の各イベントを反復処理します。
+ 各イベントから、`PayloadPart` オブジェクト内の `Bytes` オブジェクトのコンテンツを取得します。
+ 例の `_write` メソッドで、`Bytes` オブジェクトのコンテンツを連結するためにバッファーに書き込みます。組み合わせられたコンテンツは、改行で区切られた JSON ボディを形成します。
+ 例の `_readlines` メソッドを使用して、反復可能な一連の JSON オブジェクトを取得します。
+ 各 JSON オブジェクトで、推論のピースを取得します。
+ `yield` 式を使用すると、パートを段階的に返します。
次の例では、`SmrInferenceStream` オブジェクトを作成し、使用します。
```
request_body = {"inputs": ["Large model inference is"],
"parameters": {"max_new_tokens": 100,
"enable_sampling": "true"}}
smr_inference_stream = SmrInferenceStream(
sagemaker_runtime, endpoint_name)
stream = smr_inference_stream.stream_inference(request_body)
for part in stream:
print(part, end='')
```
この例では、リクエスト本文を `stream_inference` メソッドに渡しています。レスポンスを反復処理して、推論ストリームが返す各ピースを出力しています。
この例では、指定されたエンドポイントのモデルがテキストを生成する LLM であることを前提としています。この例の出力は、段階的に出力される生成テキストの本文です。
```
a challenging problem in machine learning. The goal is to . . .
```
## を使用してモデルを呼び出す AWS CLI
AWS Command Line Interface () でコマンドを実行することで、モデルエンドポイントを呼び出すことができますAWS CLI。 AWS CLI は `invoke-endpoint` コマンドによる標準的な推論リクエストをサポートし、`invoke-endpoint-async` コマンドにより非同期推論リクエストもサポートします。
**注記**
AWS CLI は、ストリーミング推論リクエストをサポートしていません。
次の例で、`invoke-endpoint` コマンドを使用して推論リクエストをモデルエンドポイントに送信します。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name endpoint_name \
--body fileb://$file_name \
output_file.txt
```
`--endpoint-name` パラメータには、エンドポイントを作成したときに指定した名前を入力します。`--body` パラメータには、SageMaker AI がモデルに渡す入力データを指定します。データは、トレーニングに使われたのと同じ形式である必要があります。この例は、バイナリデータをエンドポイントに送信する方法を示しています。
ファイルの内容を のパラメータに渡す`fileb://`ときに を`file://`いつ上書きするかの詳細については AWS CLI、[「ローカルファイルパラメータのベストプラクティス](https://aws.amazon.com/blogs/developer/best-practices-for-local-file-parameters/)」を参照してください。
渡すことができる追加のパラメータの詳細については、「AWS CLI コマンドリファレンス」の「[https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker-runtime/invoke-endpoint.html)」を参照してください。
`invoke-endpoint` コマンドが成功すると、次のようなレスポンスが返されます。
```
{
"ContentType": "; charset=utf-8",
"InvokedProductionVariant": ""
}
```
コマンドが成功しない場合は、入力ペイロードが正しい形式かどうかを確認してください。
ファイル出力ファイル (この例では `output_file.txt`) を確認することで、呼び出しの出力を表示します。
```
more output_file.txt
```
## AWS SDK for Python を使用してモデルを呼び出す
### を呼び出して推論リクエストとレスポンスを双方向にストリーミングする
アプリケーションコードでモデルエンドポイントを呼び出して双方向ストリーミングをサポートする場合は、HTTP/2 をサポートする双方向ストリーミング機能をサポートする[新しい実験的な SDK for Python](https://github.com/awslabs/aws-sdk-python) を使用できます。この SDK により、クライアントアプリケーションと SageMaker エンドポイント間のリアルタイムの双方向通信が可能になり、モデルが生成するストリーミングレスポンスを同時に受信しながら、推論リクエストを段階的に送信できます。これは、クライアントとサーバーの両方が永続的な接続を介して継続的にデータを交換する必要があるインタラクティブアプリケーションに特に役立ちます。
**注記**
新しい実験的な SDK は、標準の Boto3 SDK とは異なり、データ交換のための永続的な双方向接続をサポートしています。実験的な Python SDK を使用する場合は、実験以外のユースケースのために SDK のバージョンに厳密に固定することを強くお勧めします。
双方向ストリーミングでエンドポイントを呼び出すには、 `invoke_endpoint_with_bidirectional_stream`メソッドを使用します。このメソッドは、モデルがデータを処理するときにリアルタイムでレスポンスを受信しながら、複数のペイロードチャンクをモデルにストリーミングできる永続的な接続を確立します。入力ストリームを明示的に閉じるか、エンドポイントが接続を閉じるまで接続は開いたままになり、最大 30 分の接続時間をサポートします。
### 前提条件
アプリケーションコードで双方向ストリーミングを使用する前に、以下を行う必要があります。
1. 実験的な SageMaker ランタイム HTTP/2 SDK をインストールする
1. SageMaker ランタイムクライアントの AWS 認証情報を設定する
1. 双方向ストリーミングをサポートするモデルを SageMaker エンドポイントにデプロイする
### 双方向ストリーミングクライアントを設定する
次の例は、双方向ストリーミングに必要なコンポーネントを初期化する方法を示しています。
```
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
# Configuration
AWS_REGION = "us-west-2"
BIDI_ENDPOINT = f"https://runtime.sagemaker.{AWS_REGION}.amazonaws.com:8443"
ENDPOINT_NAME = "your-endpoint-name"
# Initialize the client configuration
config = Config(
endpoint_uri=BIDI_ENDPOINT,
region=AWS_REGION,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
# Create the SageMaker Runtime HTTP/2 client
client = SageMakerRuntimeHTTP2Client(config=config)
```
### 双方向ストリーミングクライアントを完了する
次の例は、複数のテキストペイロードを SageMaker エンドポイントに送信し、レスポンスをリアルタイムで処理する双方向ストリーミングクライアントを作成する方法を示しています。
```
import asyncio
import logging
from sagemaker_runtime_http2.client import SageMakerRuntimeHTTP2Client
from sagemaker_runtime_http2.config import Config, HTTPAuthSchemeResolver
from sagemaker_runtime_http2.models import (
InvokeEndpointWithBidirectionalStreamInput,
RequestStreamEventPayloadPart,
RequestPayloadPart
)
from smithy_aws_core.identity import EnvironmentCredentialsResolver
from smithy_aws_core.auth.sigv4 import SigV4AuthScheme
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
class SageMakerBidirectionalClient:
def __init__(self, endpoint_name, region="us-west-2"):
self.endpoint_name = endpoint_name
self.region = region
self.client = None
self.stream = None
self.response_task = None
self.is_active = False
def _initialize_client(self):
bidi_endpoint = f"runtime.sagemaker.{self.region}.amazonaws.com:8443"
config = Config(
endpoint_uri=bidi_endpoint,
region=self.region,
aws_credentials_identity_resolver=EnvironmentCredentialsResolver(),
auth_scheme_resolver=HTTPAuthSchemeResolver(),
auth_schemes={"aws.auth#sigv4": SigV4AuthScheme(service="sagemaker")}
)
self.client = SageMakerRuntimeHTTP2Client(config=config)
async def start_session(self):
"""Establish a bidirectional streaming connection with the endpoint."""
if not self.client:
self._initialize_client()
logger.info(f"Starting session with endpoint: {self.endpoint_name}")
self.stream = await self.client.invoke_endpoint_with_bidirectional_stream(
InvokeEndpointWithBidirectionalStreamInput(endpoint_name=self.endpoint_name)
)
self.is_active = True
# Start processing responses concurrently
self.response_task = asyncio.create_task(self._process_responses())
async def send_message(self, message):
"""Send a single message to the endpoint."""
if not self.is_active:
raise RuntimeError("Session not active. Call start_session() first.")
logger.info(f"Sending message: {message}")
payload = RequestPayloadPart(bytes_=message.encode('utf-8'))
event = RequestStreamEventPayloadPart(value=payload)
await self.stream.input_stream.send(event)
async def send_multiple_messages(self, messages, delay=1.0):
"""Send multiple messages with a delay between each."""
for message in messages:
await self.send_message(message)
await asyncio.sleep(delay)
async def end_session(self):
"""Close the bidirectional streaming connection."""
if not self.is_active:
return
await self.stream.input_stream.close()
self.is_active = False
logger.info("Stream closed")
# Cancel the response processing task
if self.response_task and not self.response_task.done():
self.response_task.cancel()
async def _process_responses(self):
"""Process incoming responses from the endpoint."""
try:
output = await self.stream.await_output()
output_stream = output[1]
while self.is_active:
result = await output_stream.receive()
if result is None:
logger.info("No more responses")
break
if result.value and result.value.bytes_:
response_data = result.value.bytes_.decode('utf-8')
logger.info(f"Received: {response_data}")
except Exception as e:
logger.error(f"Error processing responses: {e}")
# Example usage
async def run_bidirectional_client():
client = SageMakerBidirectionalClient(endpoint_name="your-endpoint-name")
try:
# Start the session
await client.start_session()
# Send multiple messages
messages = [
"I need help with",
"my account balance",
"I can help with that",
"and recent charges"
]
await client.send_multiple_messages(messages)
# Wait for responses to be processed
await asyncio.sleep(2)
# End the session
await client.end_session()
logger.info("Session ended successfully")
except Exception as e:
logger.error(f"Client error: {e}")
await client.end_session()
if __name__ == "__main__":
asyncio.run(run_bidirectional_client())
```
クライアントは、双方向ストリーミング接続に必要なポート 8443 のリージョンエンドポイント URI を使用して SageMaker Runtime HTTP/2 クライアントを初期化します。start\$1`session()` メソッドは `invoke_endpoint_with_bidirectional_stream()`を呼び出して永続的な接続を確立し、受信レスポンスを同時に処理する非同期タスクを作成します。
`send_event()` メソッドはペイロードデータを適切なリクエストオブジェクトにラップし、入力ストリームを介して送信します。一方、`_process_responses()`メソッドはエンドポイントからのレスポンスを継続的にリッスンして処理します。この双方向アプローチにより、リクエストの送信とレスポンスの受信の両方が同じ接続で同時に行われるリアルタイムのやり取りが可能になります。
# エンドポイント
モデルをエンドポイントにデプロイしたら、エンドポイントを表示および管理します。SageMaker AI を使用すると、エンドポイントのステータスと詳細を表示したり、メトリクスとログを確認してエンドポイントのパフォーマンスをモニタリングしたり、エンドポイントにデプロイされたモデルの更新したりなどができます。
以下のセクションでは、Amazon SageMaker Studio または AWS マネジメントコンソール でエンドポイントを管理する方法を示します。
次のページでは、Amazon SageMaker AI コンソールまたは SageMaker Studio を使用してエンドポイントをインタラクティブに表示および変更する方法について説明します。
**Topics**
+ [SageMaker Studio でエンドポイントの詳細を表示する](manage-endpoints-studio.md)
+ [SageMaker AI コンソールでエンドポイントの詳細を表示します。](manage-endpoints-console.md)
# SageMaker Studio でエンドポイントの詳細を表示する
Amazon SageMaker Studio では、SageMaker AI がホストするエンドポイントを表示および管理できます。Studio の詳細については、[Amazon SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/studio.html) を参照してください。
SageMaker Studio でエンドポイントのリストを検索するには、次の手順を実行します:
1. Studio アプリケーションを開きます。
1. 左のナビゲーションペインで **[デプロイ]** を選択します。
1. ドロップダウンメニューから**[エンドポイント]** を選択します。
**エンドポイント**ページが開き、SageMaker AI がホストするエンドポイントがすべて表示されます。このページで、エンドポイントとその**ステータス**を確認できます。新しいエンドポイントの作成、既存のエンドポイントの編集、またはエンドポイントの削除を行うこともできます。
特定のエンドポイントの詳細を表示するには、リストからエンドポイントを選択します。エンドポイントの詳細ページに、次のスクリーンショットのような概要が表示されます。
![\[Studio のエンドポイントの詳細の概要を示すエンドポイントのメインページのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/studio-endpoint-details-page.png)
各エンドポイントの詳細ページに、次の情報タブが含まれます。
# バリアント (またはモデル) の表示
**[バリアント]** タブ (エンドポイントに複数のモデルがデプロイされている場合は **[モデル]** タブとも呼ばれます) には、エンドポイントに現在デプロイされている[モデルバリアント](https://docs.aws.amazon.com/sagemaker/latest/dg/model-ab-testing.html)またはモデルのリストが表示されます。次のスクリーンショットは、複数の**モデル**がデプロイされたエンドポイントの概要と [モデル] セクションを示しています。
![\[デプロイされた複数のモデルが表示されたエンドポイントのメインページのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/studio-goldfinch-multi-model-endpoint.png)
各バリアントまたはモデルに設定を追加または編集できます。バリアントを選択し、デフォルトの自動スケーリングポリシーを有効にします。このポリシーは、後で **[自動スケーリング]** タブで編集できます。
# 設定の表示
**[設定]** タブでは、エンドポイントに関連付けられた AWS IAM ロール、暗号化に使用される AWS KMS キー (該当する場合)、VPC の名前、ネットワーク隔離設定を表示できます。
# テスト推論
**[テスト推論]** タブで、デプロイされたモデルにテスト推論リクエストを送信できます。これは、エンドポイントが期待どおりにリクエストに応答することを検証するのに便利です。
推論をテストするには、以下を実行します。
1. モデルの **[テスト推論]** タブで、次のいずれかのオプションを選択します。
1. エンドポイントをテストし、Studio インターフェイスを介してレスポンスを受け取る場合は、**[リクエスト本文を入力]** を選択します。
1. ローカル環境からエンドポイントを呼び出し、プログラムでレスポンスを受け取るために使用する AWS SDK for Python (Boto3) の例をコピーする場合は、**[サンプルコードのコピー (Python)]** を選択します。
1. **[モデル]** で、エンドポイントでテストするモデルを選択します。
1. Studio インターフェイスでテストする方法を選択した場合は、レスポンスの**コンテンツタイプ**をドロップダウンから選択することもできます。
リクエストを設定したら、**[リクエストの送信]** (Studio インターフェイス経由でレスポンスを受け取る) または **[コピー]** を選択して Python の例をコピーできます。
Studio インターフェイスから受け取るレスポンスは、次のスクリーンショットのようになります。
![\[Studio のエンドポイントで推論テストリクエストが成功したスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/endpoint-test-inference.png)
# Auto-scaling
**[Auto-scaling]** タブでは、エンドポイントでホストされているモデル用に設定された任意の Auto-scaling ポリシーを表示できます。次のスクリーンショットは、**[Auto Scaling]**タブを示しています。
![\[[Auto-scaling] タブのスクリーンショット。アクティブなポリシーが 1 つ表示されている。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/inference/studio-endpoint-autoscaling.png)
**[Auto-scaling の編集]** を選択して、任意のポリシーを変更し、デフォルトの Auto-scaling ポリシーをオンまたはオフにすることができます。
リアルタイムエンドポイントの自動スケーリングの詳細については、「[Automatically Scale Amazon SageMaker AI Models](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html)」を参照してください。エンドポイントの Auto-scaling ポリシーを設定する方法が不明な場合は、[Inference Recommender の自動スケーリングレコメンデーションジョブ](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-recommender-autoscaling.html)を使用して、Auto-scaling ポリシーのレコメンデーションを取得します。
# SageMaker AI コンソールでエンドポイントの詳細を表示します。
SageMaker AI コンソールでエンドポイントを表示するには、次の手順を実行します。
1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) に移動します。
1. 左側のナビゲーションペインで **[インターフェイス]** を選択します。
1. ドロップダウンリストから **[エンドポイント]** を選択します。
1. **[エンドポイント]** ページで、エンドポイントを選択します。
エンドポイント詳細ページが開き、エンドポイントの概要と、エンドポイント用に収集されたメトリクスが表示されます。
以下のセクションでは、エンドポイントの詳細ページのタブについて説明します。
# エンドポイントのモニタリング
SageMaker AI ホストエンドポイントを作成後、Amazon CloudWatch を使用してエンドポイントをモニタリングすることで、raw データを収集し、リアルタイムに近い読み取り可能なメトリクスに加工できます。これらのメトリクスを使用することにより、履歴情報にアクセスして、エンドポイントのパフォーマンスをより的確に把握できます。詳細については、「*[Amazon CloudWatch ユーザーガイド](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*」を参照してください。
エンドポイント詳細ページの **[モニタリング]** タブから、エンドポイントから収集された CloudWatch メトリクスデータを表示できます。
**[モニタリング]** タブには以下のセクションがあります。
+ **[運用指標]**: CPU 使用率やメモリ使用率など、エンドポイントのリソースの使用状況を追跡する指標を表示します。
+ **[呼び出しメトリクス]**: 呼び出しモデルエラーやモデルレイテンシーなど、`InvokeEndpoint` エンドポイントに送信されるリクエストの数、状態、ステータスを追跡するメトリクスを表示します。
+ **[Health メトリクス]**: 呼び出し失敗や通知失敗など、エンドポイントの全体的な状態を追跡するメトリクスを表示します。
各メトリクスの詳細な説明については、「[Monitor SageMaker AI with CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html)」を参照してください。
次のスクリーンショットは、サーバーレスエンドポイントの **[運用メトリクス]** セクションを示しています。
![\[エンドポイント詳細ページの運用メトリクスセクションにあるメトリクスグラフのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/hosting-operational-metrics.png)
特定のセクションのメトリクスについて追跡したい**期間**と**統計**、メトリクスデータを表示したい期間の長さを調整できます。**[ウィジェットの追加]** を選択して、各セクションのビューにメトリクスウィジェットを追加したり、ビューから削除したりすることもできます。**[ウィジェットの追加]** ダイアログボックスでは、表示するメトリクスを選択または選択解除できます。
利用できるメトリクスは、エンドポイントのタイプによって異なる場合があります。たとえば、サーバーレスエンドポイントには、リアルタイムエンドポイントでは利用できないメトリクスがいくつかあります。エンドポイントタイプ別のより具体的なメトリクス情報については、次のページを参照してください。
+ [サーバーレスエンドポイントをモニタリングする](https://docs.aws.amazon.com/sagemaker/latest/dg/serverless-endpoints-monitoring.html)
+ [非同期エンドポイントをモニタリングする](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-monitor.html)
+ [マルチモデルエンドポイントのデプロイのメトリクス](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoint-cloudwatch-metrics.html)
+ [推論パイプラインのログとメトリクス](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
# 設定
**[設定]** タブを選択すると、データキャプチャ設定、エンドポイント設定、タグなど、エンドポイントに関する追加情報を表示できます。
# アラームを作成する。
エンドポイント詳細ページの **[アラーム]** タブでは、メトリクスのしきい値を指定する単純な静的しきい値メトリクスアラームを表示および作成できます。メトリクスがしきい値を超えると、アラームは `ALARM` の状態になります。CloudWatch アラームの詳細については、「[Amazon CloudWatch でのアラームの使用](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)」を参照してください。
**[エンドポイントサマリー]** セクションには、エンドポイントで現在アクティブなアラームの数を示す **[アラーム]** フィールドが表示されます。
どのアラームが `ALARM` の状態にあるかを表示するには、**[アラーム]** タブを選択します。**[アラーム]** タブには、エンドポイントのアラームの全リストと、そのステータスや状態に関する詳細が表示されます。次のスクリーンショットは、エンドポイントに設定されたこのセクションのアラームのリストを示しています。
![\[CloudWatch アラームのリストが表示されているエンドポイント詳細ページの [アラーム] タブのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/hosting-alarms-tab.png)
アラームのステータスは `In alarm`、`OK`、または収集されているメトリクスデータが十分でない場合の `Insufficient data` です。
エンドポイントの新しいアラームを作成するには、次の操作を行います。
1. **[アラーム]** タブで、**[アラームの作成]** を選択します。
1. **[アラームの作成]** ページが開きます。[**アラーム名**] に、アラームの名前を入力します。
1. (オプション) アラームの説明を入力します。
1. **[メトリクス]** では、アラームに追跡させたい CloudWatch メトリクスを選択します。
1. **[バリアント名]** では、モニタリングするエンドポイントのモデルバリアントを選択します。
1. **[統計]** では、選択したメトリクスで利用できる統計を 1 つ選択します。
1. **[期間]** では、各統計値の計算に使用する期間を選択します。たとえば、平均統計と 5 分間の期間を選択した場合、アラームによって監視される各データポイントは、5 分間隔でのメトリックのデータポイントの平均になります。
1. **[評価期間]** には、アラーム状態を開始するかどうかを評価する際にアラームが考慮するデータポイントの数を入力します。
1. **[条件]** では、アラームのしきい値として使用する条件を選択します。
1. **[しきい値]** には、希望するしきい値を入力します。
1. (オプション) **[通知]** では、**[通知の追加]** を選択して、アラームの状態が変化したときに通知を受け取る Amazon SNS トピックを作成または指定できます。
1. [**アラームの作成**] を選択します。
アラームを作成したら、いつでも **[アラーム]** タブに戻ってステータスを確認できます。このセクションから、アラームを選択して **[編集]** または **[削除]** を選択することもできます。
# ホスティングオプション
次のトピックでは、利用可能な SageMaker AI リアルタイムホスティングオプションと、各ホスティングオプションの設定、呼び出し、削除の方法について説明します。
**Topics**
+ [シングルモデルエンドポイント](realtime-single-model.md)
+ [マルチモデルエンドポイント](multi-model-endpoints.md)
+ [マルチコンテナエンドポイント](multi-container-endpoints.md)
+ [Amazon SageMaker AI の推論パイプライン](inference-pipelines.md)
+ [エンドポイントとリソースを削除する](realtime-endpoints-delete-resources.md)
# シングルモデルエンドポイント
AWS SDK for Python (Boto3)、SageMaker Python SDK、または AWS CLI を使用して、単一のモデルをホストするリアルタイム推論エンドポイントを作成、更新、削除します。手順とコードの例については、「[リアルタイム推論用のモデルをデプロイする](realtime-endpoints-deploy-models.md)」を参照してください。
# マルチモデルエンドポイント
マルチモデルエンドポイントは、多数のモデルをデプロイするためのスケーラブルで費用対効果の高いソリューションを提供します。同じリソース群と共有サービングコンテナを使用して、すべてのモデルをホストします。これにより、単一モデルエンドポイントを使用する場合と比較して、エンドポイントの使用率が向上し、ホスティングコストが削減されます。また、Amazon SageMaker AI によってメモリへのモデルのロードが管理され、エンドポイントへのトラフィックパターンに基づいてモデルがスケーリングされるため、デプロイのオーバーヘッドも削減されます。
次の図は、マルチモデルエンドポイントが単一モデルのエンドポイントと比較してどのように機能するかを示しています。
![\[マルチモデルエンドポイントでホストする方法と、単一モデルのエンドポイントでモデルをホストする方法の比較を示す図。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/multi-model-endpoints-diagram.png)
マルチモデルエンドポイントは、共有サービングコンテナ上で同じ ML フレームワークを使用する多数のモデルをホストするのに理想的です。アクセス頻度の高いモデルとアクセス頻度の低いモデルが混在している場合、マルチモデルエンドポイントは、より少ないリソースと高いコスト削減でトラフィックを効率的に処理できます。使用頻度の低いモデルを呼び出すときに発生する、コールドスタート関連のレイテンシーのペナルティをアプリケーション側で許容する必要があります。
マルチモデルエンドポイントは、CPU と GPU ベースのモデル両方のホスティングをサポートします。GPU ベースのモデルを使用すると、エンドポイントとその基盤となる高速コンピューティングインスタンスの使用率が高まるため、モデルのデプロイコストを削減できます。
マルチモデルエンドポイントにより、モデル間でメモリリソースのタイムシェアリングが可能になります。これは、モデル間でサイズと呼び出しレイテンシーが酷似している場合に最適です。この場合、マルチモデルエンドポイントは、すべてのモデル間でインスタンスを効果的に使用できます。1 秒あたりのトランザクション (TPS) やレイテンシーの要件が非常に高いモデルがある場合は、専用のエンドポイントでそれらのモデルをホストすることをお勧めします。
以下の機能を備えたマルチモデルエンドポイントを使用できます。
+ [AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/userguide/endpoint-services-overview.html) VPCs
+ [Auto scaling](multi-model-endpoints-autoscaling.md)
+ [シリアル推論パイプライン](https://docs.aws.amazon.com/sagemaker/latest/dg/inference-pipelines.html) (ただし、推論パイプラインに含めることができるマルチモデル対応コンテナは 1 つだけです)
+ A/B テスト
AWS SDK for Python (Boto) または SageMaker AI コンソールを使用して、マルチモデルエンドポイントを作成できます。CPU ベースのマルチモデルエンドポイントでは、[Multi Model Server](https://github.com/awslabs/multi-model-server) ライブラリを統合することで、カスタム構築コンテナでエンドポイントを作成できます。
**Topics**
+ [マルチモデルエンドポイントの仕組み](#how-multi-model-endpoints-work)
+ [マルチモデルエンドポイントのサンプルノートブック](#multi-model-endpoint-sample-notebooks)
+ [マルチモデルエンドポイントでサポートされるアルゴリズム、フレームワーク、インスタンス](multi-model-support.md)
+ [マルチモデルエンドポイントのデプロイのためのインスタンスの推奨事項](multi-model-endpoint-instance.md)
+ [マルチモデルエンドポイントを作成する](create-multi-model-endpoint.md)
+ [マルチモデルエンドポイントを呼び出す](invoke-multi-model-endpoint.md)
+ [モデルの追加または削除](add-models-to-endpoint.md)
+ [SageMaker AI マルチモデルエンドポイント用の独自のコンテナを構築する](build-multi-model-build-container.md)
+ [マルチモデルエンドポイントのセキュリティ](multi-model-endpoint-security.md)
+ [マルチモデルエンドポイントのデプロイの CloudWatch メトリクス](multi-model-endpoint-cloudwatch-metrics.md)
+ [SageMaker AI マルチモデルエンドポイントモデルのキャッシュ動作を設定する](multi-model-caching.md)
+ [マルチモデルエンドポイントデプロイの自動スケーリングポリシーの設定](multi-model-endpoints-autoscaling.md)
## マルチモデルエンドポイントの仕組み
SageMaker AI は、コンテナのメモリ内にある、マルチモデルエンドポイントでホストされるモデルのライフサイクルを管理します。SageMaker AI では、エンドポイントの作成時に Amazon S3 バケットからコンテナにすべてのモデルをダウンロードするのではなく、モデルを呼び出したときに動的にモデルをロードしキャッシュします。SageMaker AI が特定のモデルの呼び出しリクエストを受信すると、次の処理が行われます。
1. エンドポイントの背後にあるインスタンスにリクエストをルーティングします。
1. S3 バケットからインスタンスのストレージボリュームにモデルをダウンロードします。
1. その高速コンピューティングインスタンス上のコンテナのメモリ (CPU と GPU ベースのインスタンスのどちらを使用しているかによって CPU または GPU) にモデルをロードします。モデルがコンテナのメモリにすでにロードされている場合、SageMaker AI はモデルをダウンロードしてロードする必要がないため、呼び出しが速くなります。
SageMaker AI は、モデルがすでにロードされているインスタンスに、モデルへのリクエストを引き続きルーティングします。ただし、モデルが多数の呼び出しリクエストを受信し、マルチモデルエンドポイントに追加のインスタンスがある場合、SageMaker AI はトラフィックに対応するために一部のリクエストを別のインスタンスにルーティングします。モデルが 2 番目のインスタンスにまだロードされていない場合、モデルはそのインスタンスのストレージボリュームにダウンロードされ、コンテナのメモリにロードされます。
インスタンスのメモリ使用率が高く、SageMaker AI がメモリに別のモデルをロードする必要がある場合、そのインスタンスのコンテナから未使用のモデルをアンロードして、モデルをロードするのに十分なメモリを確保します。アンロードされたモデルはインスタンスのストレージボリュームに残り、S3 バケットから再度ダウンロードすることなく、後でコンテナのメモリにロードできます。インスタンスのストレージボリュームが最大容量に達すると、SageMaker AI はストレージボリュームから未使用のモデルを削除します。
モデルを削除するには、リクエストの送信を停止し、そのモデルを S3 バケットから削除します。SageMaker AI は、サービングコンテナでマルチモデルエンドポイントの機能を提供します。マルチモデルエンドポイントに対するモデルの追加と削除では、エンドポイント自体を更新する必要はありません。モデルを追加するには、そのモデルを S3 バケットにアップロードして、その呼び出しを開始します。この機能を使用するためにコードを変更する必要はありません。
**注記**
マルチモデルエンドポイントを更新すると、マルチモデルエンドポイントのスマートルーティングがトラフィックパターンに適応するため、エンドポイントでの初回呼び出しリクエストの待ち時間が長くなる可能性があります。ただし、トラフィックパターンを学習すると、最も頻繁に使用されるモデルのレイテンシーは短くなります。使用頻度の低いモデルでは、モデルがインスタンスに動的に読み込まれるため、コールドスタートのレイテンシーが発生する可能性があります。
## マルチモデルエンドポイントのサンプルノートブック
マルチモデルエンドポイントの使用方法の詳細については、以下のサンプルノートブックを試すことができます。
+ CPU ベースのインスタンスを使用するマルチモデルエンドポイントの例。
+ [マルチモデルエンドポイント XGBoost サンプルノートブック](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html) – このノートブックでは、複数の XGBoost モデルをエンドポイントにデプロイする方法を説明します。
+ [マルチモデルエンドポイント BYOC サンプルノートブック](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_bring_your_own/multi_model_endpoint_bring_your_own.html) – このノートブックでは、SageMaker AI のマルチモデルエンドポイントをサポートするカスタムコンテナを設定およびデプロイする方法を示します。
+ GPU ベースのインスタンスを使用するマルチモデルエンドポイントの例。
+ [Amazon SageMaker AI マルチモデルエンドポイント (MME) を使用して GPU で複数の深層学習を実行する](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb) – このノートブックでは、NVIDIA Triton Inference コンテナを使用して ResNet-50 モデルをマルチモデルエンドポイントにデプロイする方法を示します。
SageMaker AI で前のサンプルを実行するために使用できる Jupyter ノートブックインスタンスを作成してアクセスする方法の詳細については、「[Amazon SageMaker ノートブックインスタンス](nbi.md)」を参照してください。ノートブックインスタンスを作成して開いた後、**[SageMaker AI サンプル]** タブを選択して、すべての SageMaker AI サンプルのリストを表示します。マルチモデルエンドポイントノートブックは **[高度な機能]** セクションにあります。ノートブックを開くには、その [**Use (使用)**] タブを選択し、[**Create copy (コピーを作成)**] を選択します。
マルチモデルエンドポイントのユースケースの詳細については、以下のブログとリソースを参照してください。
+ 動画: [SageMaker AI で何千ものモデルをホスティングする](https://www.youtube.com/watch?v=XqCNTWmHsLc&t=751s)
+ 動画: [SaaS のための SageMaker AI ML](https://www.youtube.com/watch?v=BytpYlJ3vsQ)
+ ブログ: [マルチテナント SaaS ユースケースの機械学習推論をスケーリングする方法](https://aws.amazon.com/blogs/machine-learning/how-to-scale-machine-learning-inference-for-multi-tenant-saas-use-cases/)
+ ケーススタディ: [Veeva Systems](https://aws.amazon.com/partners/success/advanced-clinical-veeva/)
# マルチモデルエンドポイントでサポートされるアルゴリズム、フレームワーク、インスタンス
マルチモデルエンドポイントで使用できるアルゴリズム、フレームワーク、インスタンスタイプについては、以下のセクションを参照してください。
## CPU ベースのインスタンスを使用するマルチモデルエンドポイントでサポートされるアルゴリズム、フレームワーク、インスタンス
次のアルゴリズムおよびフレームワークの推論コンテナは、マルチモデルエンドポイントをサポートしています。
+ [Amazon SageMaker AI の XGBoost アルゴリズム](xgboost.md)
+ [K 最近傍 (k-NN) アルゴリズム](k-nearest-neighbors.md)
+ [線形学習アルゴリズム](linear-learner.md)
+ [ランダムカットフォレスト (RCF) アルゴリズム](randomcutforest.md)
+ [Amazon SageMaker AI で TensorFlow を使用するためのリソース](tf.md)
+ [Amazon SageMaker AI で Scikit-learn を使用するためのリソース](sklearn.md)
+ [Amazon SageMaker AI で Apache MXNet を使用するためのリソース](mxnet.md)
+ [Amazon SageMaker AI で PyTorch を使用するためのリソース](pytorch.md)
他のフレームワークまたはアルゴリズムを使うには、SageMaker AI 推論ツールキットを使って、マルチモデルエンドポイントをサポートするコンテナを構築します。詳細については、「[SageMaker AI マルチモデルエンドポイント用の独自のコンテナを構築する](build-multi-model-build-container.md)」を参照してください。
マルチモデルエンドポイントはすべての CPU インスタンスタイプをサポートします。
## GPU ベースのインスタンスを使用するマルチモデルエンドポイントでサポートされるアルゴリズム、フレームワーク、インスタンス
[SageMaker AI Triton Inference Server](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) では、複数の GPU ベースのモデルのマルチモデルエンドポイントでのホスティングがサポートされています。これは、NVIDIA® TensorRT™、PyTorch、MXNet、Python、ONNX、XGBoost、scikit-learn、RandomForest、OpenVino、カスタムの C\$1\$1 など、すべての主要な推論フレームワークをサポートします。
他のフレームワークやアルゴリズムを使用するには、Python または C\$1\$1 用の Triton バックエンドを使用してモデルロジックを記述し、任意のカスタムモデルを提供できます。サーバーの準備が整ったら、1 つのエンドポイントに何百ものディープラーニングモデルのデプロイを開始できます。
マルチモデルエンドポイントは次の GPU インスタンスタイプをサポートします。
| インスタンスファミリー | インスタンスタイプ | vCPU | vCPU あたりのメモリ (GiB) | GPUs | GPU メモリ |
| --- | --- | --- | --- | --- | --- |
| p2 | ml.p2.xlarge | 4 | 15.25 | 1 | 12 |
| p3 | ml.p3.2xlarge | 8 | 7.62 | 1 | 16 |
| g5 | ml.g5.xlarge | 4 | 4 | 1 | 24 |
| g5 | ml.g5.2xlarge | 8 | 4 | 1 | 24 |
| g5 | ml.g5.4xlarge | 16 | 4 | 1 | 24 |
| g5 | ml.g5.8xlarge | 32 | 4 | 1 | 24 |
| g5 | ml.g5.16xlarge | 64 | 4 | 1 | 24 |
| g4dn | ml.g4dn.xlarge | 4 | 4 | 1 | 16 |
| g4dn | ml.g4dn.2xlarge | 8 | 4 | 1 | 16 |
| g4dn | ml.g4dn.4xlarge | 16 | 4 | 1 | 16 |
| g4dn | ml.g4dn.8xlarge | 32 | 4 | 1 | 16 |
| g4dn | ml.g4dn.16xlarge | 64 | 4 | 1 | 16 |
# マルチモデルエンドポイントのデプロイのためのインスタンスの推奨事項
マルチモデルエンドポイントの SageMaker AI ML インスタンスタイプを選択する際に考慮すべきいくつかの項目があります。
+ 提供する必要があるすべてのモデルに十分な [Amazon Elastic Block Store (Amazon EBS)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html) 容量をプロビジョニングします。
+ パフォーマンスとコストのバランスをとります (コールドスタートを最小限に抑える。インスタンスの容量を過剰にプロビジョニングしない)。エンドポイントおよびマルチモデルエンドポイントの各インスタンスタイプに SageMaker AI がアタッチするストレージボリュームのサイズについては、「[インスタンスストレージボリューム](host-instance-storage.md)」を参照してください。
+ `MultiModel` モードで動作するように設定されたコンテナの場合、そのインスタンス用にプロビジョニングされたストレージボリュームは、デフォルトの `SingleModel` モードよりも大きくなります。そのため、`SingleModel` モードより多くのモデルをインスタンスストレージボリュームにキャッシュできます。
SageMaker AI 機械学習インスタンスタイプを選択する際は、以下の点を考慮してください。
+ マルチモデルエンドポイントは、現在、すべての CPU インスタンスタイプとシングル GPU インスタンスタイプでサポートされています。
+ マルチモデルエンドポイントの背後でホストするモデルへのトラフィック分散 (アクセスパターン)、およびモデルのサイズ (インスタンスのメモリにロードできるモデルの数) に関する次の情報にご注意ください。
+ インスタンスのメモリ量は、ロードするモデルのキャッシュスペースと考えてください。vCPUs の数は、ロードされたモデルに対して推論を行うための同時実行制限と考えてください (モデルの呼び出しが CPU にバインドされていると仮定します)。
+ CPU ベースのインスタンスの場合、vCPUs の数は、インスタンスあたりの最大同時呼び出し数に影響します (モデルの呼び出しが CPU にバインドされている場合)。vCPU の量が多いほど、より多くの一意なモデルを同時に呼び出すことができます。
+ GPU ベースのインスタンスの場合、インスタンスと GPU のメモリの量が多いほど、より多くのモデルを読み込んで推論リクエストを処理できます。
+ CPU と GPU ベースのインスタンスの両方で、特に複数のインスタンスで設定されたマルチモデルエンドポイントの場合は、未使用のモデルをアンロードできるように「スラック」メモリをいくらか確保します。インスタンスまたはアベイラビリティーゾーンに障害が発生した場合、それらのインスタンスのモデルはエンドポイントの背後にある他のインスタンスに再ルーティングされます。
+ ロード/ダウンロード時間の許容範囲を確認する。
+ d インスタンスタイプファミリー (m5d、c5d、r5d など) と g5s には NVMe (不揮発性メモリエクスプレス) SSD が付属しています。これにより、I/O パフォーマンスが高まり、モデルをストレージボリュームにダウンロードする時間、モデルをストレージボリュームからコンテナにロードする時間が短くなります。
+ d および g5 インスタンスタイプには NVMe SSD ストレージが付属しているため、SageMaker AI は、マルチモデルエンドポイントをホストするこれらの機械学習コンピューティングインスタンスには Amazon EBS ストレージボリュームをアタッチしません。Auto Scaling は、モデルのサイズが同じで均質な場合、つまり推定レイテンシーとリソース要件が類似している場合に最も効果的です。
また、以下のガイダンスを使用して、マルチモデルエンドポイントへのモデル読み込みを最適化することもできます。
**対象となるモデルのすべてをメモリの範囲内に保持できないインスタンスタイプを選択する**
場合によっては、ターゲットモデルのすべてを一度にメモリに保持できないインスタンスタイプを選択することにより、コストを削減することを選択できます。SageMaker AI は、メモリが不足するとモデルを動的にアンロードして、新たにターゲットになったモデルのために空き領域を確保します。リクエストの頻度が低いモデルでは、動的ロードレイテンシーが犠牲になります。レイテンシーの要件がより厳しい場合は、より大きなインスタンスタイプまたはより多くのインスタンスを選択できます。パフォーマンステストと分析に事前に時間をかけることは、本番環境へのデプロイを成功させるのに役立ちます。
**モデルキャッシュのヒット数を評価する**
Amazon CloudWatch メトリクスはモデルの評価に役立ちます。マルチモデルエンドポイントで使用できるメトリクスの詳細については、「[マルチモデルエンドポイントのデプロイの CloudWatch メトリクス](multi-model-endpoint-cloudwatch-metrics.md)」を参照してください。
`ModelCacheHit` メトリクスの `Average` 統計を使用して、モデルがすでにロードされていたリクエストの比率をモニタリングできます。`ModelUnloadingTime` メトリクスの `SampleCount` 統計を使用して、一定期間にコンテナに送信されたアンロードリクエストの数をモニタリングできます。モデルがあまりにも頻繁にアンロードされる場合 (これは「スラッシング」の兆候であり、作業モデルのセットに十分なキャッシュ領域がないためモデルのアンロードと再ロードが繰り返される状況)、より多くのメモリを備えたより大きなインスタンスタイプの使用を検討するか、マルチモデルエンドポイントの背後にあるインスタンスの数の増加を検討します。**複数のインスタンスで設定されたマルチモデルエンドポイントの場合は、モデルが複数のインスタンスにロードされる可能性があります。
# マルチモデルエンドポイントを作成する
SageMaker AI コンソールまたは を使用して AWS SDK for Python (Boto) 、マルチモデルエンドポイントを作成できます。CPU または GPU ベースのエンドポイントをコンソールから作成するには、以下のセクションのコンソールの手順を参照してください。を使用してマルチモデルエンドポイントを作成する場合は AWS SDK for Python (Boto)、次のセクションの CPU または GPU の手順を使用します。CPU と GPU のワークフローは似ていますが、コンテナの要件など、いくつかの違いがあります。
**Topics**
+ [マルチモデルエンドポイントを作成する (コンソール)](#create-multi-model-endpoint-console)
+ [で CPUs を使用してマルチモデルエンドポイントを作成する AWS SDK for Python (Boto3)](#create-multi-model-endpoint-sdk-cpu)
+ [で GPUs を使用してマルチモデルエンドポイントを作成する AWS SDK for Python (Boto3)](#create-multi-model-endpoint-sdk-gpu)
## マルチモデルエンドポイントを作成する (コンソール)
CPU と GPU ベースのマルチモデルエンドポイントの両方をコンソールから作成できます。以下の手順に従って SageMaker AI コンソールからマルチモデルエンドポイントを作成します。
**マルチモデルエンドポイントを作成するには (コンソール)**
1. Amazon SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) を開きます。
1. [**モデル**] を選択し、[**推論**] グループから [**モデルの作成**] を選択します。
1. [**モデル名**] に名前を入力します。
1. **[IAM ロール]** で、`AmazonSageMakerFullAccess` IAM ポリシーがアタッチされた IAM ロールを選択するか作成します。
1. **[コンテナの定義]** セクションの、**[モデルアーティファクトと推論イメージオプションの提供]** で **[複数のモデルの使用]** を選択します。
![\[モデルの作成ページで [複数のモデルを使用する] を選択するセクション。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/mme-create-model-ux-2.PNG)
1. **[推論コンテナイメージ]** には、目的のコンテナイメージの Amazon ECR パスを入力します。
GPU モデルの場合は、NVIDIA Triton Inference Server を基盤とするコンテナを使用する必要があります。GPU ベースのエンドポイントで動作するコンテナイメージのリストについては、「[NVIDIA Triton Inference Containers (SM support only)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only)」を参照してください。NVIDIA Triton Inference Server の詳細については、「[Use Triton Inference Server with SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)」を参照してください。
1. **[モデルの作成]** を選択します。
1. 単一モデルエンドポイントの場合と同様に、マルチモデルエンドポイントをデプロイします。手順については、「[SageMaker AI ホスティングサービスにモデルをデプロイする](ex1-model-deployment.md#ex1-deploy-model)」を参照してください。
## で CPUs を使用してマルチモデルエンドポイントを作成する AWS SDK for Python (Boto3)
以下のセクションを使用して、CPU インスタンスベースのマルチモデルエンドポイントを作成します。マルチモデルエンドポイントは、モデルが 1 つのエンドポイントを作成する場合と同様に Amazon SageMaker AI の [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) API、[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) API、[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) API を使って作成しますが、相違点が 2 つあります。モデルコンテナを定義するときに、新しい `Mode` パラメータ値 `MultiModel` を渡す必要があります。また、1 つのモデルをデプロイするときは 1 つのモデルアーティファクトへのパスを渡しますが、代わりに、モデルアーティファクトが配置される Amazon S3 のプレフィックスを指定する `ModelDataUrl` フィールドを渡す必要があります。
SageMaker AI を使って複数の XGBoost モデルをエンドポイントにデプロイするサンプルノートブックについては、[マルチモデルエンドポイント (XGBoost) のサンプルノートブック](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html)を参照してください。
ここでは、CPU ベースのマルチモデルエンドポイントを作成するためにそのサンプルで使用される主要な手順について概説しています。
**モデルをデプロイするには (AWS SDK for Python (Boto 3))**
1. マルチモデルエンドポイントのデプロイをサポートするイメージを含んだコンテナを取得します。マルチモデルエンドポイントをサポートする組み込みアルゴリズムとフレームワークコンテナのリストについては、「[マルチモデルエンドポイントでサポートされるアルゴリズム、フレームワーク、インスタンス](multi-model-support.md)」を参照してください。この例では、組み込みのアルゴリズムの [K 最近傍 (k-NN) アルゴリズム](k-nearest-neighbors.md) を使います。[SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) のユーティリティ関数 `image_uris.retrieve()` を呼び出して、組み込みの K 最近傍アルゴリズムイメージのアドレスを取得します。
```
import sagemaker
region = sagemaker_session.boto_region_name
image = sagemaker.image_uris.retrieve("knn",region=region)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
```
1. AWS SDK for Python (Boto3) SageMaker AI クライアントを取得し、このコンテナを使用するモデルを作成します。
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. (オプション) シリアル推論パイプラインを使用している場合、パイプラインに含める追加のコンテナを取得し、`CreateModel` の `Containers` 引数に含めます。
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**注記**
シリアル推論パイプラインで使用できるマルチモデル対応エンドポイントは 1 つだけです。
1. (オプション) モデルのキャッシュによる利点がないユースケースの場合は、`MultiModelConfig` パラメータの `ModelCacheSetting` フィールドの値を `Disabled` に設定し、`create_model` 呼び出しの `Container` 引数に含めます。デフォルトでは、`ModelCacheSetting` フィールドの値は `Enabled` です。
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. モデルのマルチモデルエンドポイントを設定します。少なくとも 2 つのインスタンスでエンドポイントを設定することをお勧めします。これにより、SageMaker AI は複数のアベイラビリティーゾーン全体で可用性の高い予測のセットをモデルに提供できます。
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.m4.xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
**注記**
シリアル推論パイプラインで使用できるマルチモデル対応エンドポイントは 1 つだけです。
1. `EndpointName` および `EndpointConfigName` パラメータを使用してマルチモデルエンドポイントを作成します。
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
## で GPUs を使用してマルチモデルエンドポイントを作成する AWS SDK for Python (Boto3)
次のセクションを使用して、GPU ベースのマルチモデルエンドポイントを作成します。マルチモデルエンドポイントは、モデルが 1 つのエンドポイントを作成する場合と同様に Amazon SageMaker AI の [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) API、[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) API、[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) API を使って作成しますが、いくつかの相違点があります。モデルコンテナを定義するときに、新しい `Mode` パラメータ値 `MultiModel` を渡す必要があります。また、1 つのモデルをデプロイするときは 1 つのモデルアーティファクトへのパスを渡しますが、代わりに、モデルアーティファクトが配置される Amazon S3 のプレフィックスを指定する `ModelDataUrl` フィールドを渡す必要があります。GPU ベースのマルチモデルエンドポイントでは、GPU インスタンスでの実行に最適化された NVIDIA Triton Inference Server のコンテナも使用する必要があります。GPU ベースのエンドポイントで動作するコンテナイメージのリストについては、「[NVIDIA Triton Inference Containers (SM support only)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only)」を参照してください。
GPU ベースのマルチモデルエンドポイントを作成する方法を示すノートブックの例については、「[Run mulitple deep learning models on GPUs with Amazon SageMaker AI Multi-model endpoints (MME)](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb)」を参照してください。
ここでは、GPU ベースのマルチモデルエンドポイントを作成するための主要な手順について概説しています。
**モデルをデプロイするには (AWS SDK for Python (Boto 3))**
1. コンテナイメージを定義します。ResNet モデル用の GPU サポートを備えたマルチモデルエンドポイントを作成するには、[NVIDIA Triton Server イメージ](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)を使用するコンテナを定義します。このコンテナはマルチモデルエンドポイントをサポートし、GPU インスタンスでの実行に最適化されています。[SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/v2.html) のユーティリティ関数 `image_uris.retrieve()` を呼び出して、イメージのアドレスを取得します。例えば、次のようになります。
```
import sagemaker
region = sagemaker_session.boto_region_name
// Find the sagemaker-tritonserver image at
// https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-triton/resnet50/triton_resnet50.ipynb
// Find available tags at https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only
image = ".dkr.ecr..amazonaws.com/sagemaker-tritonserver:".format(
account_id=account_id_map[region], region=region
)
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel',
"Environment": {"SAGEMAKER_TRITON_DEFAULT_MODEL_NAME": "resnet"},
}
```
1. AWS SDK for Python (Boto3) SageMaker AI クライアントを取得し、このコンテナを使用するモデルを作成します。
```
import boto3
sagemaker_client = boto3.client('sagemaker')
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container])
```
1. (オプション) シリアル推論パイプラインを使用している場合、パイプラインに含める追加のコンテナを取得し、`CreateModel` の `Containers` 引数に含めます。
```
preprocessor_container = {
'Image': '.dkr.ecr..amazonaws.com/:'
}
multi_model_container = {
'Image': '.dkr.ecr..amazonaws.com/:',
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [preprocessor_container, multi_model_container]
)
```
**注記**
シリアル推論パイプラインで使用できるマルチモデル対応エンドポイントは 1 つだけです。
1. (オプション) モデルのキャッシュによる利点がないユースケースの場合は、`MultiModelConfig` パラメータの `ModelCacheSetting` フィールドの値を `Disabled` に設定し、`create_model` 呼び出しの `Container` 引数に含めます。デフォルトでは、`ModelCacheSetting` フィールドの値は `Enabled` です。
```
container = {
'Image': image,
'ModelDataUrl': 's3:///',
'Mode': 'MultiModel'
'MultiModelConfig': {
// Default value is 'Enabled'
'ModelCacheSetting': 'Disabled'
}
}
response = sagemaker_client.create_model(
ModelName = '',
ExecutionRoleArn = role,
Containers = [container]
)
```
1. モデルの GPU ベースのマルチモデルエンドポイントを設定します。可用性を高め、キャッシュヒット率を高めるために、エンドポイントに複数のインスタンスを設定することをお勧めします。
```
response = sagemaker_client.create_endpoint_config(
EndpointConfigName = '',
ProductionVariants=[
{
'InstanceType': 'ml.g4dn.4xlarge',
'InitialInstanceCount': 2,
'InitialVariantWeight': 1,
'ModelName': '',
'VariantName': 'AllTraffic'
}
]
)
```
1. `EndpointName` および `EndpointConfigName` パラメータを使用してマルチモデルエンドポイントを作成します。
```
response = sagemaker_client.create_endpoint(
EndpointName = '',
EndpointConfigName = '')
```
# マルチモデルエンドポイントを呼び出す
マルチモデルエンドポイントを呼び出すには、1 つのモデルエンドポイントを呼び出すのと同じように、SageMaker AI ランタイムから [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) を使います (変更が 1 点あります)。エンドポイントのどのモデルをターゲットにするかを指定する新しい `TargetModel` パラメータを渡します。SageMaker AI ランタイムの `InvokeEndpoint` リクエストは、呼び出し対象として指定されたモデルの相対パスを受け取る新しいヘッダーとして、`X-Amzn-SageMaker-Target-Model` をサポートします。SageMaker AI システムは、`CreateModel` API コールの一部として渡されるプレフィックスをモデルの相対パスと組み合わせることで、モデルの絶対パスを生成します。
以下の手順は、CPU と GPU ベースのマルチモデルエンドポイントのどちらでも同じです。
------
#### [ AWS SDK for Python (Boto 3) ]
以下の予測リクエストの例では、サンプルノートブックに [AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html) を使っています。
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName = "",
ContentType = "text/csv",
TargetModel = ".tar.gz",
Body = body)
```
------
#### [ AWS CLI ]
以下の例は、 AWS Command Line Interface (AWS CLI) を使って CSV リクエストを作成する方法を示しています。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name "" \
--body "1.0,2.0,5.0"$'\n'"2.0,3.0,4.0" \
--content-type "text/csv" \
--target-model ".tar.gz"
output_file.txt
```
推論が成功した場合は、推論リクエストに関する情報が含まれた `output_file.txt` が作成されます。で予測を行う方法のその他の例については AWS CLI、SageMaker [Python SDK ドキュメントの「 で予測を行う AWS CLI](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#making-predictions-with-the-aws-cli)」を参照してください。
------
マルチモデルエンドポイントは、必要に応じてターゲットモデルを動的にロードします。この状態になるのは、[MME サンプルノートブック](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html)の実行時に、1 つのエンドポイントの背後でホストされている複数のターゲットモデルに対するランダムな呼び出しを順次処理しているときです。特定のモデルに対する最初のリクエストには時間がかかります。これは、モデルを Amazon Simple Storage Service (Amazon S3) からダウンロードしてメモリにロードする必要があるためです これは「コールドスタート」と呼ばれ、マルチモデルエンドポイントでは顧客のコストパフォーマンスが向上するように最適化されることが期待されます。**モデルのロード後は追加のオーバーヘッドがないため、後続の呼び出しはより速く終了します。
**注記**
GPU ベースのインスタンスの場合、GPU コンテナからの 507 HTTP レスポンスコードは、メモリやその他のリソースが不足していることを示しています。これにより、使用頻度の高いモデルを読み込むために、未使用のモデルがコンテナからアンロードされます。
## ModelNotReadyException エラーに対してリクエストを再試行する
モデルに対して初めて `invoke_endpoint` を呼び出す場合、モデルは Amazon Simple Storage Service からダウンロードされ、推論コンテナにロードされます。そのため、最初の呼び出しがレスポンスを返すまでには時間がかかります。モデルがすでにロードされているため、その後の同じモデルへの呼び出しはより早く完了します。
SageMaker AI は、`invoke_endpoint` の呼び出しに対するレスポンスを 60 秒以内に返します。一部のモデルはサイズが大きく、60 秒以内にダウンロードできない場合があります。60 秒のタイムアウト制限より前にモデルのロードを完了できない場合、`invoke_endpoint` のリクエストはエラーコード `ModelNotReadyException` を返し、モデルは最大 360 秒間、推論コンテナへのダウンロードとロードを続けます。`invoke_endpoint` リクエストからエラーコード `ModelNotReadyException` を取得した場合は、リクエストを再試行してください。デフォルトでは、 AWS SDKs Python (Boto 3) ([レガシー再試行モード](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#legacy-retry-mode)を使用) および`ModelNotReadyException`エラーが発生する Java 再試行`invoke_endpoint`リクエスト。再試行の方法は、リクエストの再試行を最大 360 秒間継続するように設定できます。コンテナへのモデルのダウンロードとロードに 60 秒以上かかることが予想される場合は、SDK ソケットタイムアウトを 70 秒に設定します。 AWS SDK for Python (Boto3)の再試行方法を設定する方法の詳細については、「[Configuring a retry mode](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/retries.html#configuring-a-retry-mode)」を参照してください。次のコードは、`invoke_endpoint` の呼び出しを最大 180 秒間再試行する再試行方法を設定する例を示しています。
```
import boto3
from botocore.config import Config
# This example retry strategy sets the retry attempts to 2.
# With this setting, the request can attempt to download and/or load the model
# for upto 180 seconds: 1 orginal request (60 seconds) + 2 retries (120 seconds)
config = Config(
read_timeout=70,
retries={
'max_attempts': 2 # This value can be adjusted to 5 to go up to the 360s max timeout
}
)
runtime_sagemaker_client = boto3.client('sagemaker-runtime', config=config)
```
# モデルの追加または削除
追加のモデルをマルチモデルエンドポイントにデプロイし、そのエンドポイントからすぐにそれらモデルを呼び出すことができます。新しいモデルを追加するときは、エンドポイントを更新または停止する必要がないため、新しいモデルごとに個別のエンドポイントを作成して実行するコストを回避できます。モデルを追加および削除するプロセスは、CPU と GPU ベースのマルチモデルエンドポイントでも同じです。
SageMaker AI は、インスタンスがメモリの最大容量に達し、さらにモデルをコンテナにダウンロードする必要があると、コンテナから未使用のモデルをアンロードします。また、SageMaker AI は、ボリュームが最大容量に達し、新しいモデルをダウンロードする必要があると、インスタンスストレージボリュームから未使用のモデルアーティファクトを削除します。新しく追加されたモデルの最初の呼び出し時間は長くなります。これは、エンドポイントがモデルを S3 から、エンドポイントをホストするインスタンスのコンテナのメモリにダウンロードするのに時間がかかるためです。
エンドポイントがすでに実行されている状態で、モデルアーティファクトの新しいセットを、モデルを保存する Amazon S3 の場所にコピーします。
```
# Add an AdditionalModel to the endpoint and exercise it
aws s3 cp AdditionalModel.tar.gz s3://amzn-s3-demo-bucket/path/to/artifacts/
```
**重要**
モデルを更新するには、新しいモデルを追加するときと同様に進めます。新しい一意の名前を使用します。Amazon S3 のモデルアーティファクトを上書きしないでください。これは、コンテナ、またはエンドポイント上のインスタンスのストレージボリュームにモデルの古いバージョンが引き続きロードされる可能性があるためです。新しいモデルを呼び出すと、モデルの古いバージョンが呼び出されることがあります。
クライアントアプリケーションは、追加のターゲットモデルが S3 に保存されるとすぐに、そのモデルに予測をリクエストできます。
```
response = runtime_sagemaker_client.invoke_endpoint(
EndpointName='',
ContentType='text/csv',
TargetModel='AdditionalModel.tar.gz',
Body=body)
```
マルチモデルエンドポイントからモデルを削除するには、クライアントからのモデルの呼び出しを停止し、モデルアーティファクトが保存されている S3 の場所からそのモデルを削除します。
# SageMaker AI マルチモデルエンドポイント用の独自のコンテナを構築する
独自のコンテナと依存関係をマルチモデルエンドポイントに導入する方法については、以下のセクションを参照してください。
**Topics**
+ [CPU ベースのインスタンスにマルチモデルエンドポイント用の独自の依存関係を持たせる](#build-multi-model-container-cpu)
+ [GPU ベースのインスタンスにマルチモデルエンドポイント用の独自の依存関係を持たせる](#build-multi-model-container-gpu)
+ [SageMaker AI 推論ツールキットを使う](#multi-model-inference-toolkit)
+ [マルチモデルエンドポイント用のカスタムコンテナの規約](mms-container-apis.md)
## CPU ベースのインスタンスにマルチモデルエンドポイント用の独自の依存関係を持たせる
ビルド済みのコンテナイメージがどれもニーズを満たさない場合は、CPU ベースのマルチモデルエンドポイントで使用する独自のコンテナを構築できます。
Amazon SageMaker AI にデプロイされたカスタム Amazon Elastic Container Registry (Amazon ECR) イメージは、独自の推論コードを実行する Docker コンテナと SageMaker AI がやり取りする方法を管理する基本的な規約 (「[ホスティングサービスでのカスタム推論コードの使用](your-algorithms-inference-code.md)」を参照) に従う必要があります。コンテナが複数のモデルを同時にロードして処理できるようにするには、追加の API と動作に従う必要があります。この追加の規約には、モデルをロード、一覧表示、取得、アンロードするための新しい API と、モデルを呼び出すための別の API が含まれます。エラーシナリオに対して API が従う必要のあるさまざまな動作も含まれます。コンテナが追加の要件に準拠していることを示すために、以下のコマンドを Docker ファイルに追加できます。
```
LABEL com.amazonaws.sagemaker.capabilities.multi-models=true
```
また、SageMaker AI によって環境変数がコンテナに挿入されます。
```
SAGEMAKER_MULTI_MODEL=true
```
シリアル推論パイプラインのマルチモデルエンドポイントを作成する場合、Docker ファイルには、マルチモデルとシリアル推論パイプラインの両方の必須ラベルが必要です。シリアル情報パイプラインの詳細については、「[推論パイプラインでリアルタイム予測を実行する](inference-pipeline-real-time.md)」を参照してください。
カスタムコンテナにこれらの要件を実装するために、2 つのライブラリが利用できます。
+ [Multi Model Server](https://github.com/awslabs/multi-model-server) は、コンテナにインストールできる機械学習モデルを提供するためのオープンソースフレームワークであり、新しいマルチモデルエンドポイントコンテナ API の要件を満たすフロントエンドを提供します。このライブラリは、1 つのコンテナ内で複数のモデルをホストし、コンテナに対してモデルを動的にロードおよびアンロードするために、マルチモデルエンドポイントに必要になる HTTP フロントエンドおよびモデル管理機能を備え、指定されてロードされたモデルで推論を実行します。また、独自のアルゴリズムを実装できるプラガブルなカスタムバックエンドハンドラをサポートする、プラガブルなバックエンドも提供します。
+ [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit) は、SageMaker AI マルチモデルエンドポイントと互換性のある構成と設定で Multi Model Server をブートストラップするライブラリです。また、シナリオのニーズに応じて、モデルごとのワーカー数などの重要なパフォーマンスパラメータを調整できます。
## GPU ベースのインスタンスにマルチモデルエンドポイント用の独自の依存関係を持たせる
GPU ベースのインスタンスを備えたマルチモデルエンドポイントでの独自のコンテナの持ち込み (BYOC) 機能は、マルチモデルサーバーおよび SageMaker AI Inference Toolkit ライブラリでは現在サポートされていません。
GPU ベースのインスタンスでマルチモデルエンドポイントを作成するには、SageMaker AI がサポートする [NVIDIA Triton 推論サーバー](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)と [NVIDIA Triton 推論コンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only)を使用できます。独自の依存関係を持たせるには、SageMaker AI がサポートする [NVIDIA Triton 推論サーバー](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)を Docker ファイルのベースイメージとして使用して独自のコンテナを構築できます。
```
FROM 301217895009.dkr.ecr.us-west-2.amazonaws.com/sagemaker-tritonserver:22.07-py3
```
**重要**
GPU ベースのマルチモデルエンドポイントに使用できるコンテナは、Triton Inference Server を備えたコンテナだけです。
## SageMaker AI 推論ツールキットを使う
**注記**
SageMaker AI 推論ツールキットは CPU ベースのマルチモデルエンドポイントでのみサポートされます。SageMaker AI 推論ツールキットは現在 GPU ベースのマルチモデルエンドポイントではサポートされていません。
マルチモデルエンドポイントをサポートするビルド済みコンテナは、「[マルチモデルエンドポイントでサポートされるアルゴリズム、フレームワーク、インスタンス](multi-model-support.md)」に記載されています。他のフレームワークやアルゴリズムを使用する場合は、コンテナを構築する必要があります。これを行う最も簡単な方法は、[SageMaker AI 推論ツールキット](https://github.com/aws/sagemaker-inference-toolkit)を使って既存の構築済みコンテナを拡張することです。SageMaker AI 推論ツールキットは、SageMaker AI にデプロイできるエンドポイントを作成するマルチモデルサーバー (MMS) の実装 です。SageMaker AI のマルチモデルエンドポイントをサポートするカスタムコンテナを設定およびデプロイする方法を示すサンプルノートブックについては、[マルチモデルエンドポイント BYOC のサンプルノートブック](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_bring_your_own)を参照してください。
**注記**
SageMaker AI 推論ツールキットは Python のモデルハンドラのみをサポートします。他の言語でハンドラを実装する場合は、追加のマルチモデルエンドポイント API を実装する独自のコンテナを構築する必要があります。詳細については、「[マルチモデルエンドポイント用のカスタムコンテナの規約](mms-container-apis.md)」を参照してください。
**SageMaker AI 推論ツールキットを使ってコンテナを拡張するには**
1. モデルハンドラを作成します。MMS は、前処理、モデルからの事前エディションの取得、およびモデルハンドラでの出力処理のための関数を実装する Python ファイルである、モデルハンドラを想定しています。モデルハンドラの例については、サンプルノートブックの [model\$1handler.py](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/model_handler.py) を参照してください。
1. 推論ツールキットをインポートし、その `model_server.start_model_server` 関数を使用して MMS を起動します。次の例は、サンプルノートブックの `dockerd-entrypoint.py` ファイルからのものです。`model_server.start_model_server` を呼び出すと、前のステップで説明したモデルハンドラが 渡されます。
```
import subprocess
import sys
import shlex
import os
from retrying import retry
from subprocess import CalledProcessError
from sagemaker_inference import model_server
def _retry_if_error(exception):
return isinstance(exception, CalledProcessError or OSError)
@retry(stop_max_delay=1000 * 50,
retry_on_exception=_retry_if_error)
def _start_mms():
# by default the number of workers per model is 1, but we can configure it through the
# environment variable below if desired.
# os.environ['SAGEMAKER_MODEL_SERVER_WORKERS'] = '2'
model_server.start_model_server(handler_service='/home/model-server/model_handler.py:handle')
def main():
if sys.argv[1] == 'serve':
_start_mms()
else:
subprocess.check_call(shlex.split(' '.join(sys.argv[1:])))
# prevent docker exit
subprocess.call(['tail', '-f', '/dev/null'])
main()
```
1. `Dockerfile` では、最初のステップからのモデルハンドラをコピーし、前のステップの Python ファイルを `Dockerfile` のエントリポイントとして指定します 。次の行は、サンプルノートブックで使用されている [Dockerfile](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/advanced_functionality/multi_model_bring_your_own/container/Dockerfile) からのものです。
```
# Copy the default custom service file to handle incoming data and inference requests
COPY model_handler.py /home/model-server/model_handler.py
# Define an entrypoint script for the docker image
ENTRYPOINT ["python", "/usr/local/bin/dockerd-entrypoint.py"]
```
1. コンテナを構築して登録します。サンプルノートブックの次のシェルスクリプトは、コンテナを構築し、 AWS アカウントの Elastic Container Registry リポジトリにアップロードします。
```
%%sh
# The name of our algorithm
algorithm_name=demo-sagemaker-multimodel
cd container
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi
# Get the login command from ECR and execute it directly
$(aws ecr get-login --region ${region} --no-include-email)
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -q -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
これで、このコンテナを使って SageMaker AI でマルチモデルエンドポイントをデプロイできるようになりました。
**Topics**
+ [CPU ベースのインスタンスにマルチモデルエンドポイント用の独自の依存関係を持たせる](#build-multi-model-container-cpu)
+ [GPU ベースのインスタンスにマルチモデルエンドポイント用の独自の依存関係を持たせる](#build-multi-model-container-gpu)
+ [SageMaker AI 推論ツールキットを使う](#multi-model-inference-toolkit)
+ [マルチモデルエンドポイント用のカスタムコンテナの規約](mms-container-apis.md)
# マルチモデルエンドポイント用のカスタムコンテナの規約
複数のモデルを処理するには、Amazon SageMaker AI がコンテナと通信して必要に応じてモデルをロード、一覧表示、取得、アンロードできるようにする API のセットを、コンテナがサポートする必要があります。`model_name` は、キー入力パラメータとして新しい API のセットで使用されます。カスタマーコンテナでは、マッピングキーとして `model_name` を使用して、ロードされたモデルを追跡する必要があります。また、`model_name` は不透明な識別子であり、必ずしも `InvokeEndpoint` API に渡される `TargetModel` パラメータの値ではありません。`InvokeEndpoint` リクエストの元の `TargetModel` 値は、ログ記録の目的で使用できる `X-Amzn-SageMaker-Target-Model` ヘッダーとして API のコンテナに渡されます。
**注記**
GPU ベースのインスタンス用のマルチモデルエンドポイントは、現在 SageMaker AI の [NVIDIA Triton Inference Server コンテナ](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html)でのみサポートされています。このコンテナには、以下に定義されている規約が既に実装されています。顧客は、追加作業なしで、このコンテナをマルチモデルの GPU エンドポイントで直接使用できます。
CPU ベースのマルチモデルエンドポイント用に、次の API をコンテナに設定できます。
**Topics**
+ [Load Model API](#multi-model-api-load-model)
+ [List Model API](#multi-model-api-list-model)
+ [Get Model API](#multi-model-api-get-model)
+ [Unload Model API](#multi-model-api-unload-model)
+ [Invoke Model API](#multi-model-api-invoke-model)
## Load Model API
本文の `url` フィールドにある特定のモデルをカスタマーコンテナのメモリにロードし、割り当てられた `model_name` で追跡するように、コンテナに指示します。モデルがロードされたら、コンテナでは、この `model_name` を使用して推論リクエストを処理する準備ができています。
```
POST /models HTTP/1.1
Content-Type: application/json
Accept: application/json
{
"model_name" : "{model_name}",
"url" : "/opt/ml/models/{model_name}/model",
}
```
**注記**
`model_name` がすでにロードされている場合、この API は 409 を返します。メモリの不足や他のいずれかのリソースが原因でモデルをロードできない場合、この API は SageMaker AI に 507 HTTP ステータスコードを返します。これにより、未使用のモデルのアンロードが開始されて再利用できるようになります。
## List Model API
カスタマーコンテナのメモリにロードされたモデルのリストを返します。
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
この API はページ分割もサポートしています。
```
GET /models HTTP/1.1
Accept: application/json
Response =
{
"models": [
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
},
....
]
}
```
SageMaker AI は、最初に `next_page_token` の値を指定せずに List Model API を呼び出すことができます。`nextPageToken` フィールドがレスポンスの一部として返された場合、後続の List Models コールで `next_page_token` の値として渡されます。`nextPageToken` が返されなかった場合、返されるモデルがこれ以上ないということです。
## Get Model API
これは、`model_name` エンティティの単純な読み取り API です。
```
GET /models/{model_name} HTTP/1.1
Accept: application/json
{
"modelName" : "{model_name}",
"modelUrl" : "/opt/ml/models/{model_name}/model",
}
```
**注記**
`model_name` がロードされていない場合、この API は 404 を返します。
## Unload Model API
SageMaker AI プラットフォームにカスタマーコンテナのメモリからのモデルのアンロードを指示します。これにより、新しいモデルのロードプロセスが開始されると、プラットフォームによって候補とされたモデルの削除が開始されます。`model_name` にプロビジョニングされたリソースは、この API がレスポンスを返すときにコンテナによって解放される必要があります。
```
DELETE /models/{model_name}
```
**注記**
`model_name` がロードされていない場合、この API は 404 を返します。
## Invoke Model API
指定された特定の `model_name` への予測リクエストを作成します。SageMaker AI ランタイムの `InvokeEndpoint` リクエストは、呼び出し対象として指定されたモデルの相対パスを受け取る新しいヘッダーとして、`X-Amzn-SageMaker-Target-Model` をサポートします。SageMaker AI システムは、`CreateModel` API コールの一部として渡されるプレフィックスをモデルの相対パスと組み合わせることで、モデルの絶対パスを生成します。
```
POST /models/{model_name}/invoke HTTP/1.1
Content-Type: ContentType
Accept: Accept
X-Amzn-SageMaker-Custom-Attributes: CustomAttributes
X-Amzn-SageMaker-Target-Model: [relativePath]/{artifactName}.tar.gz
```
**注記**
`model_name` がロードされていない場合、この API は 404 を返します。
さらに GPU インスタンスでは、メモリの不足や他のいずれかのリソースが原因で `InvokeEndpoint` に障害が発生した場合、この API は SageMaker AI に 507 HTTP ステータスコードを返します。これにより、未使用のモデルのアンロードが開始されて再利用できるようになります。
# マルチモデルエンドポイントのセキュリティ
マルチモデルエンドポイントのモデルとデータは、インスタンスストレージボリュームとコンテナメモリに共存します。Amazon SageMaker AI エンドポイントのすべてのインスタンスは、ユーザーが所有する 1 つのテナントコンテナで動作します。モデルはマルチモデルエンドポイントでのみ実行できます。モデルに対するリクエストのマッピングの管理、適切なターゲットモデルへのアクセスをユーザーに提供することは、ユーザーの責任において行います。SageMaker AI は [IAM ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)を使って IAM アイデンティティベースのポリシーを提供します。ポリシーは、アクションとリソースの許可または拒否、およびアクションが許可または拒否される条件を指定します。
デフォルトでは、マルチモデルエンドポイントにあり、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) 許可を持つ IAM プリンシパルは、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) オペレーションで定義された S3 プレフィックスのアドレスにある任意のモデルを呼び出すことができます (オペレーションで定義された IAM 実行ロールが、モデルをダウンロードする許可を持っていることを前提とします)。S3 の限定されたモデルセットへの [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) アクセスを制限する必要がある場合は、次のいずれかを実行できます。
+ `sagemaker:TargetModel` IAM 条件キーを使って、エンドポイントでホストされている特定のモデルへの `InvokeEndpont` 呼び出しを制限します。たとえば、次のポリシーでは、`TargetModel` フィールドの値が指定された正規表現のいずれかに一致する場合にのみ `InvokeEndpont` リクエストを許可します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource":
"arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": ["company_a/*", "common/*"]
}
}
}
]
}
```
------
Amazon SageMaker AI の条件キーの詳細については、*AWS Identity and Access Management ユーザーガイド*の「[Condition Keys for Amazon SageMaker AI](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys)」を参照してください。
+ より制限の厳しい S3 プレフィックスを持つマルチモデルエンドポイントを作成します。
SageMaker AI がロールを使ってエンドポイントへのアクセスを管理し、ユーザーに代わってオペレーションを実行する方法の詳細については、「[SageMaker AI 実行ロールの使用方法](sagemaker-roles.md)」を参照してください。また、独自のコンプライアンス要件によって定められた特定のデータ分離要件を顧客が設定しており、それを IAM アイデンティティを使って満たすことができる場合があります。
# マルチモデルエンドポイントのデプロイの CloudWatch メトリクス
Amazon SageMaker AI はエンドポイントのメトリクスを提供するため、キャッシュヒットレート、ロードされたモデルの数のほか、マルチモデルエンドポイントでのモデルのロード、ダウンロード、アップロードの際に生じる待機時間をモニタリングできます。CPU と GPU ベースのマルチモデルエンドポイントではメトリクスの一部が異なるため、以下のセクションでは、マルチモデルエンドポイントの種類ごとに使用できる Amazon CloudWatch メトリクスについて説明します。
メトリクスの詳細については、「[Amazon CloudWatch における Amazon SageMaker AI メトリクス](monitoring-cloudwatch.md)」の「**Multi-Model Endpoint Model Loading Metrics**」と「**Multi-Model Endpoint Model Instance Metrics**」を参照してください。モデル単位のメトリクスはサポートされていません。
## CPU ベースのマルチモデルエンドポイントの CloudWatch メトリクス
CPU ベースのマルチモデルエンドポイントでは、以下のメトリクスをモニタリングできます。
`AWS/SageMaker` 名前空間には、[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) の呼び出しからの次のモデル読み込みメトリクスが含まれます。
メトリクスは、1 分間隔で利用できます。
CloudWatch メトリクスの保持期間の詳細については、Amazon CloudWatch API リファレンスの「*GetMetricStatistics*」を参照してください。[https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)
**マルチモデルエンドポイントモデルのロードメトリクス**
| メトリクス | 説明 |
| --- | --- |
| ModelLoadingWaitTime | 推論を実行するために、呼び出しリクエストがターゲットモデルのダウンロード、ロード、またはその両方を待機する時間間隔。 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
| ModelUnloadingTime | コンテナの `UnloadModel` API コールを介してモデルをアンロードするのにかかった時間間隔。 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
| ModelDownloadingTime | Amazon Simple Storage Service (Amazon S3) からモデルをダウンロードするのにかかった時間間隔。 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
| ModelLoadingTime | コンテナの `LoadModel` API コールを介してモデルをロードするのにかかった時間間隔。 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
| ModelCacheHit | モデルが既にロードされているマルチモデルエンドポイントに送信された `InvokeEndpoint` リクエストの数。 Average 統計は、モデルが既にロードされていたリクエストの比率を示します。 単位: なし 有効な統計: Average、Sum、Sample Count |
**マルチモデルエンドポイントモデルのロードメトリクスのディメンション**
| ディメンション | 説明 |
| --- | --- |
| EndpointName, VariantName | 指定のエンドポイントおよびバリアントの `ProductionVariant` のエンドポイント呼び出しメトリクスをフィルタリングします。 |
`/aws/sagemaker/Endpoints` 名前空間には、[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) の呼び出しからの次のインスタンスメトリクスが含まれます。
メトリクスは、1 分間隔で利用できます。
CloudWatch メトリクスの保持期間の詳細については、Amazon CloudWatch API リファレンスの「*GetMetricStatistics*」を参照してください。[https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)
**マルチモデルエンドポイントモデルのインスタンスメトリクス**
| メトリクス | 説明 |
| --- | --- |
| LoadedModelCount | マルチモデルエンドポイントのコンテナにロードされたモデルの数。このメトリクスはインスタンスあたりで発行されます。 1 分間の Average 統計は、ロードされたモデルのインスタンスあたりの平均数を示します。 Sum 統計は、エンドポイントのすべてのインスタンス間でロードされたモデルの総数を示します。 モデルがエンドポイントの複数のコンテナにロードされる可能性があるため、このメトリクスが追跡するモデルは必ずしも一意ではありません。 単位: なし 有効な統計: Average、Sum、Min、Max、Sample Count |
| CPUUtilization | 個々の CPU コアの使用率の合計。各コアの CPU 使用率の範囲は 0～100 です。例えば、CPU が 4 つの場合、`CPUUtilization` の範囲は 0%～400% になります。 エンドポイントのバリアントの場合、値はインスタンス上のプライマリコンテナと補足コンテナの CPU 使用率の合計です。 単位: パーセント |
| MemoryUtilization | インスタンス上のコンテナによって使用されているメモリの割合。この値の範囲は 0%～100% です。 エンドポイントのバリアントの場合、値はインスタンス上のプライマリコンテナと補足コンテナのメモリ使用率の合計です。 単位: パーセント |
| DiskUtilization | インスタンス上のコンテナによって使用されているディスク容量の割合。この値の範囲は 0%～100% です。 エンドポイントのバリアントの場合、値はインスタンス上のプライマリコンテナと補足コンテナのディスク容量使用率の合計です。 単位: パーセント |
## GPU マルチモデルエンドポイントのデプロイの CloudWatch メトリクス
GPU ベースのマルチモデルエンドポイントでは、以下のメトリクスを監視できます。
`AWS/SageMaker` 名前空間には、[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) の呼び出しからの次のモデル読み込みメトリクスが含まれます。
メトリクスは、1 分間隔で利用できます。
CloudWatch メトリクスの保持期間の詳細については、Amazon CloudWatch API リファレンスの「*GetMetricStatistics*」を参照してください。[https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)
**マルチモデルエンドポイントモデルのロードメトリクス**
| メトリクス | 説明 |
| --- | --- |
| ModelLoadingWaitTime | 推論を実行するために、呼び出しリクエストがターゲットモデルのダウンロード、ロード、またはその両方を待機する時間間隔。 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
| ModelUnloadingTime | コンテナの `UnloadModel` API コールを介してモデルをアンロードするのにかかった時間間隔。 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
| ModelDownloadingTime | Amazon Simple Storage Service (Amazon S3) からモデルをダウンロードするのにかかった時間間隔。 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
| ModelLoadingTime | コンテナの `LoadModel` API コールを介してモデルをロードするのにかかった時間間隔。 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
| ModelCacheHit | モデルが既にロードされているマルチモデルエンドポイントに送信された `InvokeEndpoint` リクエストの数。 Average 統計は、モデルが既にロードされていたリクエストの比率を示します。 単位: なし 有効な統計: Average、Sum、Sample Count |
**マルチモデルエンドポイントモデルのロードメトリクスのディメンション**
| ディメンション | 説明 |
| --- | --- |
| EndpointName, VariantName | 指定のエンドポイントおよびバリアントの `ProductionVariant` のエンドポイント呼び出しメトリクスをフィルタリングします。 |
`/aws/sagemaker/Endpoints` 名前空間には、[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) の呼び出しからの次のインスタンスメトリクスが含まれます。
メトリクスは、1 分間隔で利用できます。
CloudWatch メトリクスの保持期間の詳細については、Amazon CloudWatch API リファレンスの「*GetMetricStatistics*」を参照してください。[https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)
**マルチモデルエンドポイントモデルのインスタンスメトリクス**
| メトリクス | 説明 |
| --- | --- |
| LoadedModelCount | マルチモデルエンドポイントのコンテナにロードされたモデルの数。このメトリクスはインスタンスあたりで発行されます。 1 分間の Average 統計は、ロードされたモデルのインスタンスあたりの平均数を示します。 Sum 統計は、エンドポイントのすべてのインスタンス間でロードされたモデルの総数を示します。 モデルがエンドポイントの複数のコンテナにロードされる可能性があるため、このメトリクスが追跡するモデルは必ずしも一意ではありません。 単位: なし 有効な統計: Average、Sum、Min、Max、Sample Count |
| CPUUtilization | 個々の CPU コアの使用率の合計。各コアの CPU 使用率の範囲は 0～100 です。例えば、CPU が 4 つの場合、`CPUUtilization` の範囲は 0%～400% になります。 エンドポイントのバリアントの場合、値はインスタンス上のプライマリコンテナと補足コンテナの CPU 使用率の合計です。 単位: パーセント |
| MemoryUtilization | インスタンス上のコンテナによって使用されているメモリの割合。この値の範囲は 0%～100% です。 エンドポイントのバリアントの場合、値はインスタンス上のプライマリコンテナと補足コンテナのメモリ使用率の合計です。 単位: パーセント |
| GPUUtilization | インスタンス上のコンテナによって使用されている GPU の割合。値の範囲は 0～100 で、GPU の数を乗算します。例えば、GPU が 4 つの場合、`GPUUtilization` の範囲は 0%～400% になります。 エンドポイントのバリアントの場合、値はインスタンス上のプライマリコンテナと補足コンテナの GPU 使用率の合計です。 単位: パーセント |
| GPUMemoryUtilization | インスタンス上のコンテナによって使用されている GPU メモリの割合。値の範囲は 0～100 で、GPU の数を乗算します。例えば、GPU が 4 つの場合、`GPUMemoryUtilization` の範囲は 0%～400% になります。 エンドポイントのバリアントの場合、値はインスタンス上のプライマリコンテナと補足コンテナの GPU メモリ使用率の合計です。 単位: パーセント |
| DiskUtilization | インスタンス上のコンテナによって使用されているディスク容量の割合。この値の範囲は 0%～100% です。 エンドポイントのバリアントの場合、値はインスタンス上のプライマリコンテナと補足コンテナのディスク容量使用率の合計です。 単位: パーセント |
# SageMaker AI マルチモデルエンドポイントモデルのキャッシュ動作を設定する
デフォルトでは、マルチモデルエンドポイントは、低レイテンシーの推論を可能にするために、頻繁に使用されるモデルをメモリ（CPU または GPU ベースのどちらかに応じて CPU または GPU）とディスクに、頻繁に使用されるモデルをキャッシュします。キャッシュされたモデルがディスクからアンロードまたは削除されるのは、新しいターゲットモデルに対応してコンテナのメモリまたはディスク領域が不足した場合のみです。
[create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) を呼び出したときにパラメータ `ModelCacheSetting` を設定することで、マルチモデルエンドポイントのキャッシュ動作を変更し、モデルキャッシュを明示的に有効または無効にできます。
モデルのキャッシュによる利点がないユースケースの場合は、`ModelCacheSetting` パラメータの値を `Disabled` に設定することをお勧めします。例えば、エンドポイントから多数のモデルを提供する必要があるものの、各モデルが 1 回のみ (または非常にまれに) 呼び出される場合などです。このようなユースケースでは、`ModelCacheSetting` パラメータの値を `Disabled` に設定にすると、デフォルトのキャッシュモードと比較して、`invoke_endpoint` リクエストに対する 1 秒あたりのトランザクション処理件数 (TPS) が多くなります。これらのユースケースで TPS が多くなるのは、SageMaker AI が `invoke_endpoint` リクエスト受信後に以下を実行するためです。
+ モデルをメモリから非同期的にアンロードし、呼び出された直後にディスクから削除する。
+ 推論コンテナでモデルをダウンロード、ロードする際に、同時実行数を増やす CPU と GPU ベースのエンドポイントの両方で、同時実行数は、コンテナインスタンスの vCPU 数の因数です。
マルチモデルエンドポイントの SageMaker AI 機械学習インスタンスタイプを選択する際のガイドラインについては、「[マルチモデルエンドポイントのデプロイのためのインスタンスの推奨事項](multi-model-endpoint-instance.md)」を参照してください。
# マルチモデルエンドポイントデプロイの自動スケーリングポリシーの設定
SageMaker AI マルチモデルエンドポイントでは自動スケーリングが完全にサポートされており、モデルのレプリカは管理され、モデルはトラフィックパターンに基づいてスケーリングされます。[マルチモデルエンドポイントのデプロイのためのインスタンスの推奨事項](multi-model-endpoint-instance.md) に基づいてマルチモデルエンドポイントとインスタンスのサイズを設定し、さらに、エンドポイントのインスタンスベースの自動スケーリングも設定することをお勧めします。自動スケーリングイベントのトリガーに使用される呼び出し率は、エンドポイントが提供するすべてのモデルのセットのすべての予測のセットに基づいています。エンドポイントの自動スケーリングの設定に関する詳細については、「[Automatically Scale Amazon SageMaker AI Models](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html)」を参照してください。
CPU と GPU ベースのマルチモデルエンドポイントの両方に、事前定義済みのメトリクスとカスタムメトリクスを使用して自動スケーリングポリシーを設定できます。
**注記**
SageMaker AI マルチモデルエンドポイントのメトリクスは 1 分単位で利用できます。
## スケーリングポリシーを定義する
スケーリングポリシーのメトリクスとターゲット値を指定するには、ターゲット追跡スケーリングポリシーを設定します。事前定義されたメトリクスまたはカスタムメトリクスのいずれかを使用できます。
スケーリングポリシー設定は JSON ブロックで表現されます。スケーリングポリシー設定を JSON ブロックとしてテキストファイルに保存します。 AWS CLI または Application Auto Scaling API を呼び出すときに、そのテキストファイルを使用します。ポリシー設定構文の詳細については、*Application Auto Scaling API リファレンス*の「`[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)`」を参照してください。
ターゲット追跡スケーリングポリシー設定を定義するには、次のオプションを使用できます。
### 事前定義メトリクスを使用する
バリアントのターゲット追跡スケーリングポリシーを時間をかけずに定義するには、事前定義された `SageMakerVariantInvocationsPerInstance` メトリクスを使用します。`SageMakerVariantInvocationsPerInstance` は、バリアントの各インスタンスの 1 分あたりの呼び出しの平均回数です。このメトリクスを使用することを強く推奨します。
スケーリングポリシーで事前定義されたメトリクスを使用するには、スケーリングポリシーのターゲット追跡設定を作成します。ターゲット追跡設定に、事前定義されたメトリクスの `PredefinedMetricSpecification` と、そのメトリクスのターゲット値の `TargetValue` が含まれている必要があります。
次の例では、バリアントのターゲット追跡スケーリングの一般的なポリシー設定について説明します。この設定では、事前定義された `SageMakerVariantInvocationsPerInstance` メトリクスを使用してバリアントのインスタンス数を調整し、各インスタンスの `InvocationsPerInstance` メトリクスが `70` になるようにします。
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "InvocationsPerInstance"
}
}
```
**注記**
マルチモデルエンドポイントを使用する際には `InvocationsPerInstance` を使用することをお勧めします。このメトリクスの `TargetValue` は、アプリケーションのレイテンシー要件によって異なります。また、エンドポイントの負荷テストを行い、適切なスケーリングパラメータ値を設定することをお勧めします。負荷テストとエンドポイントの自動スケーリングの設定の詳細については、ブログ「[Configuring autoscaling inference endpoints in Amazon SageMaker AI](https://aws.amazon.com/blogs/machine-learning/configuring-autoscaling-inference-endpoints-in-amazon-sagemaker/)」を参照してください。
### カスタムメトリクスを使用する
カスタム要件を満たすようにターゲット追跡スケーリングポリシーを定義する必要がある場合は、カスタムメトリクスを定義します。スケーリングに比例して変動する本番稼働用バリアントのメトリクスに基づいて、カスタムメトリクスを定義することができます。
SageMaker AI メトリクスにはターゲット追跡に使用できないものもあります。メトリクスは、有効な使用率メトリクスで、インスタンスの使用頻度を示す必要があります。バリアントのインスタンス数に反比例してメトリクスの値を増減する必要があります。つまり、インスタンス数が増えるときはメトリクスの値が減る必要があります。
**重要**
自動スケーリングを本稼働環境にデプロイする前に、カスタムメトリクスを使用して自動スケーリングをテストする必要があります。
#### CPU ベースのマルチモデルエンドポイントのカスタムメトリクスの例
次の例は、スケーリングポリシーのターゲット追跡設定を示します。この設定では、`my-model` という名前のモデルについて、カスタムメトリクス `CPUUtilization` が CPU 平均使用率 50% に基づいてエンドポイントのインスタンス数を全インスタンスにわたって調整します。
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
#### GPU ベースのマルチモデルエンドポイントのカスタムメトリクスの例
次の例は、スケーリングポリシーのターゲット追跡設定を示します。この設定では、`my-model` という名前のモデルについて、カスタムメトリクス `GPUUtilization` が GPU 平均使用率 50% に基づいてエンドポイントのインスタンス数を全インスタンスにわたって調整します。
```
{"TargetValue": 50,
"CustomizedMetricSpecification":
{"MetricName": "GPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "ModelName","Value": "my-model"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
## クールダウン期間を追加する
エンドポイントのスケールアウトのクールダウン期間を追加するには、`ScaleOutCooldown` の値を秒単位で指定します。同様に、モデルのスケールインのクールダウン期間を追加するには、`ScaleInCooldown` の値を秒単位で指定します。`ScaleInCooldown` と `ScaleOutCooldown` の詳細については、*Application Auto Scaling API リファレンス*の「`[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)`」を参照してください。
次に、スケーリングポリシーのターゲット追跡設定の例を示します。この設定では、事前定義された `SageMakerVariantInvocationsPerInstance` メトリクスを使用して、バリアントの全インスタンスの平均 `70` に基づいてそのスケーリングを調整します。この構成では、10 分間のスケールインのクールダウン期間と 5 分間のスケールアウトのクールダウン期間が提供されます。
```
{"TargetValue": 70.0,
"PredefinedMetricSpecification":
{"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
# マルチコンテナエンドポイント
SageMaker AI マルチコンテナエンドポイントを使用すると、1 つの SageMaker AI エンドポイントに、異なるモデルやフレームワークを使用する複数のコンテナをデプロイできます。コンテナは、推論パイプラインとして順番に実行することも、エンドポイントの使用率を向上させ、コストを最適化するために直接呼び出しを使って各コンテナに個別にアクセスすることもできます。
マルチコンテナエンドポイントのコンテナを順番に呼び出す方法については、「[Amazon SageMaker AI の推論パイプライン](inference-pipelines.md)」を参照してください。
マルチコンテナエンドポイントの特定のコンテナを呼び出す方法については、「[直接呼び出しが設定されたマルチコンテナエンドポイントを呼び出す](multi-container-direct.md)」を参照してください。
**Topics**
+ [マルチコンテナエンドポイントを作成する (Boto3)](multi-container-create.md)
+ [マルチコンテナエンドポイントを更新する](multi-container-update.md)
+ [直接呼び出しが設定されたマルチコンテナエンドポイントを呼び出す](multi-container-direct.md)
+ [直接呼び出しが設定されたマルチコンテナエンドポイントのセキュリティ](multi-container-security.md)
+ [直接呼び出しが設定されたマルチコンテナエンドポイントのメトリクス](multi-container-metrics.md)
+ [マルチコンテナエンドポイントをオートスケーリングする](multi-container-auto-scaling.md)
+ [マルチコンテナエンドポイントをトラブルシューティングする](multi-container-troubleshooting.md)
# マルチコンテナエンドポイントを作成する (Boto3)
他のエンドポイントを作成する場合と同様に、[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) API、[CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) API、[CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) API を呼び出してマルチコンテナエンドポイントを作成します。これらのコンテナは、推論パイプラインとして順番に実行することも、直接呼び出しを使ってコンテナを 1 つずつ実行することもできます。`create_model` を呼び出す場合、マルチコンテナエンドポイントは次の要件を満たす必要があります。
+ `PrimaryContainer` パラメータの代わりに `Containers` パラメータを使い、複数のコンテナを `Containers` パラメータに含めます。
+ 直接呼び出しを使う場合は、マルチコンテナエンドポイント内の各コンテナに `ContainerHostname` パラメータが必要です。
+ 各コンテナの直接呼び出しには `InferenceExecutionConfig` フィールドの `Mode` パラメータを `Direct` に設定するか、または `Serial` を設定してコンテナを推論パイプラインとして使います。デフォルトモードは `Serial` です。
**注記**
現在、マルチコンテナエンドポイントでサポートされるコンテナは最大 15 個に制限されています。
次の例では、直接呼び出し用のマルチコンテナモデルを作成します。
1. コンテナの要素と直接呼び出しに設定した `InferenceExecutionConfig` を作成します。
```
container1 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage1:mytag',
'ContainerHostname': 'firstContainer'
}
container2 = {
'Image': '123456789012.dkr.ecr.us-east-1.amazonaws.com/myimage2:mytag',
'ContainerHostname': 'secondContainer'
}
inferenceExecutionConfig = {'Mode': 'Direct'}
```
1. コンテナ要素を使ってモデルを作成し、`InferenceExecutionConfig` フィールドを設定します。
```
import boto3
sm_client = boto3.Session().client('sagemaker')
response = sm_client.create_model(
ModelName = 'my-direct-mode-model-name',
InferenceExecutionConfig = inferenceExecutionConfig,
ExecutionRoleArn = role,
Containers = [container1, container2]
)
```
エンドポイントを作成するには、次に [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) と [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) を呼び出します (他のエンドポイントを作成する場合と同様です)。
# マルチコンテナエンドポイントを更新する
Amazon SageMaker AI マルチコンテナエンドポイントを更新するには、次のステップを実行します。
1. [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) を呼び出して、`InferenceExecutionConfig` フィールドの `Mode` パラメータに新しい値を持つ新しいモデルを作成します。
1. [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) を呼び出して、前のステップで作成した新しいモデルを使い、別の名前で新しいエンドポイント設定を作成します。
1. [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_endpoint) を呼び出して、前のステップで作成した新しいエンドポイント設定を使い、エンドポイントを更新します。
# 直接呼び出しが設定されたマルチコンテナエンドポイントを呼び出す
SageMaker AI マルチコンテナエンドポイントを使うと、複数のコンテナをデプロイして SageMaker AI エンドポイントに異なるモデルをデプロイできます。1 つのエンドポイントで、最大 15 個の異なる推論コンテナをホストできます。直接呼び出しを使うと、マルチコンテナエンドポイントでホストされている特定の推論コンテナにリクエストを送信できます。
直接呼び出しが設定されたマルチコンテナエンドポイントを呼び出すには、他のエンドポイントを呼び出す場合と同様に [invoke\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) を呼び出し、呼び出すコンテナを `TargetContainerHostname` パラメータを使って指定します。
次の例では、マルチコンテナエンドポイントの `secondContainer` を直接呼び出して、予測を取得します。
```
import boto3
runtime_sm_client = boto3.Session().client('sagemaker-runtime')
response = runtime_sm_client.invoke_endpoint(
EndpointName ='my-endpoint',
ContentType = 'text/csv',
TargetContainerHostname='secondContainer',
Body = body)
```
マルチコンテナエンドポイントへの各直接呼び出しリクエストでは、`TargetContainerHostname` を持つコンテナのみが呼び出しリクエストを処理します。次のいずれかを実行すると、検証エラーが発生します。
+ エンドポイントに存在しない `TargetContainerHostname` を指定する
+ 直接呼び出し用に設定されたエンドポイントへのリクエストに `TargetContainerHostname` の値を指定しない
+ 直接呼び出し用に設定されていないエンドポイントへのリクエストに `TargetContainerHostname` の値を指定する
# 直接呼び出しが設定されたマルチコンテナエンドポイントのセキュリティ
直接呼び出しが設定されたマルチコンテナエンドポイントでは、メモリとストレージボリュームを共有する複数のコンテナが単一のインスタンス内でホストされます。セキュアなコンテナの使用、ターゲットコンテナに対するリクエストの正しいマッピングの維持、ターゲットコンテナへの適切なアクセスをユーザーに提供することは、ユーザーの責任において行います。SageMaker AI は IAM ロールを使って IAM アイデンティティベースのポリシーを提供します。ポリシーは、そのロールのリソースへのアクセスをどのような条件で許可または拒否するかどうかを指定するために使います。IAM ロールの詳細については、*AWS Identity and Access Management ユーザーガイド*の「[IAM ロール](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html)」をご参照ください。アイデンティティベースのポリシーの詳細については、「[アイデンティティベースおよびリソースベースのポリシー](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html)」を参照してください。
デフォルトでは、直接呼び出しが設定されたマルチコンテナエンドポイントに対する `InvokeEndpoint` 許可を持つ IAM プリンシパルは、`invoke_endpoint` を呼び出したときに指定したエンドポイント名を使って、そのエンドポイント内の任意のコンテナを呼び出せます。`invoke_endpoint` アクセス許可をマルチコンテナエンドポイント内の限定されたコンテナセットに制限する必要がある場合は、`sagemaker:TargetContainerHostname` IAM 条件キーを使います。次のポリシーは、エンドポイント内の特定のコンテナに対する呼び出しを制限する方法を示しています。
次のポリシーでは、指定された正規表現のいずれかに `TargetContainerHostname` フィールドの値が一致する場合にのみ `invoke_endpoint` リクエストを許可します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"customIps*",
"common*"
]
}
}
}
]
}
```
------
次のポリシーでは、`Deny` ステートメントで指定された正規表現のいずれかに `TargetContainerHostname` フィールドの値が一致する場合は `invoke_endpoint` リクエストを拒否します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Allow",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"model_name*"
]
}
}
},
{
"Action": [
"sagemaker:InvokeEndpoint"
],
"Effect": "Deny",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/endpoint_name",
"Condition": {
"StringLike": {
"sagemaker:TargetModel": [
"special-model_name*"
]
}
}
}
]
}
```
------
SageMaker AI の条件キーの詳細については、*AWS Identity and Access Management ユーザーガイド*の「[Condition Keys for SageMaker AI](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonsagemaker.html#amazonsagemaker-policy-keys)」を参照してください。
# 直接呼び出しが設定されたマルチコンテナエンドポイントのメトリクス
「[Amazon CloudWatch における Amazon SageMaker AI メトリクス](monitoring-cloudwatch.md)」に示されているエンドポイントメトリックスに加えて、SageMaker AI はコンテナ単位のメトリクスも提供します。
直接呼び出しが設定されたマルチコンテナエンドポイントのコンテナ単位のメトリクスは CloudWatch にあり、`AWS/SageMaker` と `aws/sagemaker/Endpoints` の 2 つの名前空間に分類されています。`AWS/SageMaker` 名前空間には、呼び出し関連のメトリクスが含まれており、`aws/sagemaker/Endpoints` 名前空間には、メモリおよび CPU 使用率のメトリクスが含まれています。
次の表は、直接呼び出しが設定されたマルチコンテナエンドポイントの、コンテナ単位のメトリクスを示しています。すべてのメトリクスは [`EndpointName, VariantName, ContainerName`] ディメンションを使います。特定のバリアントと特定のコンテナに対応するディメンションは、特定のエンドポイントのメトリクスをフィルタリングします。これらのメトリクスは、推論パイプラインのメトリクス名と同じメトリクス名を共有しますが、共有レベルはコンテナ単位 [`EndpointName, VariantName, ContainerName`] です。
| | | | |
| --- |--- |--- |--- |
| メトリクス名 | 説明 | ディメンション | NameSpace |
| Invocations | エンドポイント内のコンテナに送信された InvokeEndpoint リクエストの数。そのコンテナに送信されたリクエストの合計数を得るには、Sum 統計を使います。単位: なし、有効な統計: Sum、Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation4XX Errors | 特定のコンテナについて、モデルが 4xx HTTP レスポンスコードを返した InvokeEndpoint リクエスト数。各 4xx レスポンスに、SageMaker AI は 1 を送信します。単位: なし、有効な統計: Average、Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| Invocation5XX Errors | 特定のコンテナについて、モデルが 5xx HTTP レスポンスコードを返した InvokeEndpoint リクエスト数。各 5xx レスポンスに、SageMaker AI は 1 を送信します。単位: なし、有効な統計: Average、Sum | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| ContainerLatency | SageMaker AI から見たときに、ターゲットコンテナが応答にかかった時間。ContainerLatency には、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかった時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。単位: マイクロ秒、有効な統計: Average、Sum、Min、Max、Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| OverheadLatency | オーバーヘッドのため、SageMaker AI によるクライアントリクエストへの応答にかかった時間に加算される時間。OverheadLatency は、SageMaker AI がリクエストを受信してからクライアントにレスポンスを返すまでの時間から ModelLatency を引いたものです。オーバーヘッドのレイテンシーは、リクエストとレスポンスのペイロードサイズ、リクエストの頻度、リクエストの認証、認可などの要因によって異なります。単位: マイクロ秒、有効な統計: Average、Sum、Min、Max、Sample Count | EndpointName, VariantName, ContainerName | AWS/SageMaker |
| CPUUtilization | インスタンスで実行されているコンテナが使っている CPU ユニットの割合。値の範囲は 0%～100% で、CPU の数で乗算されます。例えば、CPU が 4 つの場合、CPUUtilization は 0%～400% になります。直接呼び出しが設定されたエンドポイントの場合、CPUUtilization メトリクスの数は、そのエンドポイント内のコンテナの数と等しくなります。単位: パーセント | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
| MemoryUtilizaton | インスタンスで実行されているコンテナが使っているメモリの割合。この値は 0%～100% です。CPUUtilization と同様に、直接呼び出しが設定されたエンドポイントの場合、MemoryUtilization メトリクスの数は、そのエンドポイント内のコンテナの数と等しくなります。単位: パーセント | EndpointName, VariantName, ContainerName | aws/sagemaker/Endpoints |
上表のすべてのメトリクスは、直接呼び出しが設定されたマルチコンテナエンドポイントに固有のものです。これらの特別なコンテナ単位のメトリクスの他に、表内のすべてのメトリクスには、ディメンション `[EndpointName, VariantName]` のバリアントレベルのメトリクスもあります (`ContainerLatency` を除く)。
# マルチコンテナエンドポイントをオートスケーリングする
`InvocationsPerInstance` メトリクスを使って、マルチコンテナエンドポイントのオートスケーリングを設定する場合、各コンテナでは、推論リクエストに対して同様の CPU 使用率とレイテンシーを示すモデルを使うことをお勧めします。これが推奨されるのは、マルチコンテナエンドポイントへのトラフィックが CPU 使用率が低いモデルから CPU 使用率が高いモデルに変化しても、全体的な呼び出しボリュームが同じままである場合、エンドポイントはスケールアウトされないためです。また、CPU 使用率が高いモデルに対するすべてのリクエストを処理するインスタンスが足りなくなる可能性があります。エンドポイントをオートスケーリングする方法については、「[Amazon SageMaker AI モデルの自動スケーリング](endpoint-auto-scaling.md)」を参照してください。
# マルチコンテナエンドポイントをトラブルシューティングする
以下のセクションは、マルチコンテナエンドポイントで発生したエラーのトラブルシューティングに役立ちます。
## Ping ヘルスチェックエラー
複数のコンテナがある場合、エンドポイント作成時にはエンドポイントメモリと CPU の負荷が高くなります。具体的には、`MemoryUtilization` と `CPUUtilization` のメトリクスがコンテナを 1 つ持つエンドポイントよりも高くなります。使用負荷はコンテナの数に比例するためです。このため、十分なメモリと CPU を持つインスタンスタイプを選択して、インスタンスにすべてのモデルをロードするのに十分なメモリが存在するようにすることをお勧めします (推論パイプラインのデプロイにもこの同じガイダンスが適用されます)。そうしない場合、`XXX did not pass the ping health check` などのエラーが発生してエンドポイントの作成が失敗する可能性があります。
## accept-bind-to-port=true Docker ラベルがない
マルチコンテナエンドポイントのコンテナは、(8080 ポートではなく) `SAGEMAKER_BIND_TO_PORT` 環境変数で指定されたポートでリッスンします。マルチコンテナエンドポイントでコンテナが実行されると、SageMaker AI は自動的にこの環境変数をコンテナに提供します。この環境変数が存在しない場合、コンテナではデフォルトでポート 8080 が使用されます。コンテナがこの要件に準拠していることを示すには、次のコマンドを使用して Dockerfile にラベルを追加します。
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
追加しない場合は、`Your Ecr Image XXX does not contain required com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true Docker label(s).` などのエラーメッセージが表示されます。
コンテナが 2 番目のポートをリッスンする必要がある場合は、`SAGEMAKER_SAFE_PORT_RANGE` 環境変数で指定された範囲内のポートを選択してください。「*XXXX*-*YYYY*」の形式の包含範囲として値を指定します。ここで、XXXX と YYYY は複数桁の整数です。マルチコンテナエンドポイントでこのコンテナを実行する場合、SageMaker AI はこの値を自動的に提供します。
# Amazon SageMaker AI の推論パイプライン
*推論パイプライン*は、データに対して推論リクエストを処理する、直線状に並んだ 2～15 個のコンテナで構成される Amazon SageMaker AI モデルです。推論パイプラインを使って、事前トレーニング済みの SageMaker AI 組み込みアルゴリズムと、Docker コンテナにパッケージ化された独自のカスタムアルゴリズムの任意の組み合わせを定義、デプロイします。推論パイプラインを使用して、事前処理、予測、および後処理のデータサイエンスタスクを組み合わせることができます。推論パイプラインは完全に管理されます。
SageMaker AI Spark ML Serving と scikit-learn コンテナを追加すると、モデルトレーニング用に開発されたデータ変換を再利用できます。組み立てられた推論パイプライン全体は、リアルタイム予測の実行や、外部の前処理をせずにバッチ変換を直接処理するために使うことができる SageMaker AI モデルと見なすことができます。
推論パイプラインモデル内で、SageMaker AI は呼び出しを HTTP リクエストのシーケンスとして処理します。最初のリクエストはパイプラインの最初のコンテナによって処理され、次に中間レスポンスが 2 番目のコンテナへのリクエストとして送信され、以降、パイプラインの各コンテナに対して同様の処理が繰り返され、最終レスポンスが SageMaker AI によってクライアントに返されます。
パイプラインモデルをデプロイすると、SageMaker AI はエンドポイントまたは変換ジョブの各 Amazon Elastic Compute Cloud (Amazon EC2) インスタンスにすべてのコンテナをインストールし、実行します。機能の処理と推測は低レイテンシーで実行されます。これは、コンテナが同じ EC2 インスタンスに配置されているためです。[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) オペレーションを使用するか、コンソールから、パイプラインモデルのコンテナを定義します。`PrimaryContainer` を 1 つ設定する代わりに、`Containers` パラメータを使用して、パイプラインを構成する複数のコンテナを設定します。また、コンテナを実行する順序も指定します。
パイプラインモデルは変更不可能ですが、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) オペレーションを使用して新しいモデルをデプロイすることにより、推論パイプラインを更新できます。このモジュール性により、実験中の柔軟性が高まります。
SageMaker モデルレジストリを使って推論パイプラインを作成する方法については、「[Model Registry を使用したモデル登録デプロイ](model-registry.md)」を参照してください。
この機能の使用に追加料金はかかりません。エンドポイントで実行されているインスタンスに対してのみ料金が発生します。
**Topics**
+ [推論パイプラインのサンプルノートブック](#inference-pipeline-sample-notebooks)
+ [SparkML と Scikit-learn による機能処理](inference-pipeline-mleap-scikit-learn-containers.md)
+ [パイプラインモデルを作成する](inference-pipeline-create-console.md)
+ [推論パイプラインでリアルタイム予測を実行する](inference-pipeline-real-time.md)
+ [推論パイプラインを使用したバッチ変換](inference-pipeline-batch.md)
+ [推論パイプラインのログとメトリクス](inference-pipeline-logs-metrics.md)
+ [推論パイプラインのトラブルシューティング](inference-pipeline-troubleshoot.md)
## 推論パイプラインのサンプルノートブック
推論パイプラインを作成してデプロイする方法を示す例については、「[Inference Pipeline with Scikit-learn and Linear Learner](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/scikit_learn_inference_pipeline)」サンプルノートブックを参照してください。SageMaker AI でサンプルを実行する際に使用できる Jupyter ノートブックインスタンスを作成してアクセスする手順については、「[Amazon SageMaker ノートブックインスタンス](nbi.md)」を参照してください。
ノートブックインスタンスを作成して開いた後、すべての SageMaker AI サンプルのリストを表示するには、**[SageMaker AI サンプル]** タブを選択します。推論パイプラインノートブックは 3 つあります。説明した最初の 2 つの推論パイプラインノートブックは `advanced_functionality` フォルダにあり、3 番目のノートブックは `sagemaker-python-sdk` フォルダにあります。ノートブックを開くには、その [**使用**] タブを選び、次に [**コピーを作成**] を選択します。
# SparkML と Scikit-learn による機能処理
Amazon SageMaker AI 組み込みアルゴリズムまたは独自のカスタムアルゴリズムを使ってモデルをトレーニングする前に、Spark および scikit-learn のプリプロセッサを使ってデータを変換し、特徴エンジニアリングをします。
## Spark ML による機能処理
Spark ML ジョブは、[AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html)、サーバーレス ETL (抽出、変換、ロード) サービスを使って SageMaker AI ノートブックから実行できます。既存の EMR クラスターに接続し、[Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html) で Spark ML ジョブを実行することもできます。これを行うには、SageMaker AI ノートブックから への呼び出しを行うためのアクセス許可を付与する AWS Identity and Access Management (IAM) ロールが必要です AWS Glue。
**注記**
AWS Glue サポートされている Python および Spark のバージョンを確認するには、[AWS 「 Glue リリースノート](/glue/latest/dg/release-notes.html)」を参照してください。
エンジニアリング機能の後で、推論パイプラインに追加できる MLeap コンテナに、Spark ML ジョブを MLeap でパッケージ化およびシリアル化します。外部で管理された Spark クラスターを使用する必要はありません。この方法では、サンプルの行からテラバイト単位のデータにシームレスにスケールできます。同じトランスフォーマーがトレーニングおよび推論の両方で機能するため、事前処理や機能エンジニアリングロジックを複製したり、モデルを保持するための 1 回限りのソリューションを開発したりする必要はありません。推論パイプラインでは、外部のインフラストラクチャを維持する必要はなく、データ入力から直接予測を行うことができます。
Spark ML ジョブを実行すると AWS Glue、Spark ML パイプラインは [MLeap](https://github.com/combust/mleap) 形式にシリアル化されます。その後、SageMaker AI 推論パイプラインで [SparkML Model Serving コンテナ](https://github.com/aws/sagemaker-sparkml-serving-container)を使ったジョブを使用できます。*MLeap* は、Machine Learning パイプライン用のシリアル化フォーマットおよび実行エンジンです。Spark、Scikit-learn、TensorFlow をサポートして、パイプラインをトレーニングし、それらを MLeap Bundle と呼ばれるシリアル化されたパイプラインにエクスポートします。バンドルは、バッチモードスコアリングのために Spark に逆シリアル化したり、リアルタイム API サービスに使用するために MLeap ランタイムに逆シリアル化したりできます。
Spark ML を使用して特徴量処理を行う方法を示す例については、「[Train an ML Model using Apache Spark in Amazon EMR and deploy in SageMaker AI](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-python-sdk/sparkml_serving_emr_mleap_abalone)」サンプルノートブックを参照してください。
## sci-kit learn を使って特徴を処理する
scikit-learn のジョブは Amazon SageMaker AI で直接実行し、コンテナにパッケージ化できます。[フィッシャーのアイリスの花のデータセット](http://archive.ics.uci.edu/ml/datasets/Iris)で学習し、さらに形態学的測定に基づいてアイリスの種を予測するシック学習風の特徴化モデルを作成するための Python コードの例については、「[Sagemaker による IRIS トレーニングと予測](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk/scikit_learn_iris)」を参照してください。
# パイプラインモデルを作成する
エンドポイントにデプロイ可能なパイプラインまたはバッチ変換ジョブに使われるパイプラインを作成するには、Amazon SageMaker AI コンソールまたは `CreateModel` オペレーションを使います。
**推測パイプラインを作成するには (コンソール)**
1. Amazon SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) を開きます。
1. **[Models]** (モデル) を選択し、**[Inference]** (推論) グループから **[Create models]** (モデルの作成) を選択します。
1. **[モデルの作成]** ページで、モデル名を指定し、IAM ロールを選択します。さらに、プライベート VPC を使う場合は、VPC の値を指定します。
![\[推論パイプラインのモデルの作成ページ。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/create-pipeline-model.png)
1. 推論パイプラインのコンテナに関する情報を追加するには、[**コンテナの追加**] を選択し、次に [**次へ**] を選択します。
1. 各コンテナのフィールドに入力します (実行順に最大 15 個まで)。[**コンテナ入力オプション**]、[**推論コードイメージの場所**]、オプションとして [**モデルアーティファクトの場所**]、[**コンテナホスト名**]、[**環境変数**] フィールドに入力します。
![\[コンテナを使用したパイプラインモデルの作成。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/create-pipeline-model-containers.png)
[**MyInferencePipelineModel**] ページでは、モデルの入力を示すコンテナ設定の概要が表示されます。対応するコンテナの定義で環境変数を指定すると、SageMaker AI は **[環境変数]** フィールドを表示します。
![\[パイプラインモデルのコンテナ設定の概要。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/pipeline-MyInferencePipelinesModel-recap.png)
# 推論パイプラインでリアルタイム予測を実行する
トレーニングされたモデルは、外部の事前処理なしに直接リアルタイム予測を行うための推論パイプラインで使用することができます。パイプラインを設定する際に、Amazon SageMaker AI ですでに利用可能な組み込みの特徴変換機能を使うように選択できます。または、数行の scikit-learn または Spark コードのみを使用して、独自の変換ロジックを実装できます。
機械学習パイプライン用のシリアル化形式および実行エンジンである [MLeap](https://combust.github.io/mleap-docs/) は、パイプラインのトレーニングと、MLeap Bundle と呼ばれるシリアル化されたパイプラインへのエクスポートのため、Spark、scikit-learn、および TensorFlow をサポートしています。バンドルは、バッチモードスコアリングのために Spark に逆シリアル化したり、リアルタイム API サービスに使用するために MLeap ランタイムに逆シリアル化したりできます。
パイプラインのコンテナは、(8080 ではなく) `SAGEMAKER_BIND_TO_PORT` 環境変数で指定されたポートでリッスンします。推論パイプラインで実行する際、SageMaker AI はコンテナにこの環境変数を自動的に提供します。この環境変数が存在しない場合、コンテナではデフォルトでポート 8080 が使用されます。コンテナがこの要件に準拠していることを示すには、次のコマンドを使用して Dockerfile にラベルを追加します。
```
LABEL com.amazonaws.sagemaker.capabilities.accept-bind-to-port=true
```
コンテナが 2 番目のポートをリッスンする必要がある場合は、`SAGEMAKER_SAFE_PORT_RANGE` 環境変数で指定された範囲内のポートを選択してください。**"XXXX-YYYY"** の形式の包含範囲として値を指定します。ここで、`XXXX` と `YYYY` は複数桁の整数です。マルチコンテナエンドパイプラインでこのコンテナを実行する場合、SageMaker AI はこの値を自動的に提供します。
**注記**
[SageMaker AI 組み込みアルゴリズム](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html)を含むパイプラインでカスタム Docker イメージを使う場合は、[Amazon Elastic Container Registry (Amazon ECR) ポリシー](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)が必要です。Amazon ECR リポジトリは、イメージをプルする許可を SageMaker AI に付与する必要があります。詳細については、「[推論パイプラインの Amazon ECR アクセス許可のトラブルシューティングを行う](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions)」を参照してください。
## 推論パイプラインエンドポイントの作成とデプロイ
次のコードは、SageMaker AI SDK を使用して、SparkML モデルと XGBoost モデルを順に使ってリアルタイム推論パイプラインモデルを作成およびデプロイします。
```
from sagemaker.model import Model
from sagemaker.pipeline_model import PipelineModel
from sagemaker.sparkml.model import SparkMLModel
sparkml_data = 's3://{}/{}/{}'.format(s3_model_bucket, s3_model_key_prefix, 'model.tar.gz')
sparkml_model = SparkMLModel(model_data=sparkml_data)
xgb_model = Model(model_data=xgb_model.model_data, image=training_image)
model_name = 'serial-inference-' + timestamp_prefix
endpoint_name = 'serial-inference-ep-' + timestamp_prefix
sm_model = PipelineModel(name=model_name, role=role, models=[sparkml_model, xgb_model])
sm_model.deploy(initial_instance_count=1, instance_type='ml.c4.xlarge', endpoint_name=endpoint_name)
```
## 推論パイプラインエンドポイントからのリアルタイムの推論リクエスト
次のコード例は、推論エンドポイントを呼び出して JSON 形式のリクエストペイロードを渡すことによって、リアルタイムの予測を行う方法を示しています。
```
import sagemaker
from sagemaker.predictor import json_serializer, json_deserializer, Predictor
payload = {
"input": [
{
"name": "Pclass",
"type": "float",
"val": "1.0"
},
{
"name": "Embarked",
"type": "string",
"val": "Q"
},
{
"name": "Age",
"type": "double",
"val": "48.0"
},
{
"name": "Fare",
"type": "double",
"val": "100.67"
},
{
"name": "SibSp",
"type": "double",
"val": "1.0"
},
{
"name": "Sex",
"type": "string",
"val": "male"
}
],
"output": {
"name": "features",
"type": "double",
"struct": "vector"
}
}
predictor = Predictor(endpoint=endpoint_name, sagemaker_session=sagemaker.Session(), serializer=json_serializer,
content_type='text/csv', accept='application/json')
print(predictor.predict(payload))
```
`predictor.predict(payload)` から得るレスポンスは、モデルの推論結果です。
## リアルタイム推論パイプラインの例
エンドポイントをデプロイし、推論リクエストを実行し、レスポンスを逆シリアル化する方法を示す [SKLearn 予測子を使用して、この例のノートブック](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-python-sdk/scikit_learn_randomforest/Sklearn_on_SageMaker_end2end.ipynb)を実行できます。このノートブックやその他の例は、[Amazon SageMaker サンプル GitHub リポジトリ](https://github.com/awslabs/amazon-sagemaker-examples)にあります。
# 推論パイプラインを使用したバッチ変換
データセット全体の推論を取得するには、トレーニングされたモデルに対してバッチ変換を実行します。データセット全体に対して推論を実行するには、リアルタイム処理用として作成し、エンドポイントにデプロイした同じ推論パイプラインモデルを、バッチ変換ジョブで使用できます。パイプライン内のバッチ変換ジョブを実行するには、入力データを Amazon S3 からダウンロードし、そのデータを 1 つ以上の HTTP リクエストで推論パイプラインモデルに送信します。バッチ変換のデータを準備する方法を示す例については、「[Amazon SageMaker Multi-Model Endpoints using Linear Learner sample notebook](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/multi_model_linear_learner_home_value)」の「Section 2 - Preprocess the raw housing data using Scikit Learn」を参照してください。Amazon SageMaker AI バッチ変換については、「[Amazon SageMaker AI による推論のためのバッチ変換](batch-transform.md)」を参照してください。
**注記**
[Amazon SageMaker AI 組み込みアルゴリズム](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html)を含むパイプラインでカスタム Docker イメージを使う場合は、[Amazon Elastic Container Registry (ECR) ポリシー](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)が必要です。Amazon ECR リポジトリは、イメージをプルする許可を SageMaker AI に付与する必要があります。詳細については、「[推論パイプラインの Amazon ECR アクセス許可のトラブルシューティングを行う](inference-pipeline-troubleshoot.md#inference-pipeline-troubleshoot-permissions)」を参照してください。
次の例は、[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) を使って変換ジョブを実行する方法を示しています。この例では、`model_name` は SparkML と XGBoost モデルを組み合わせた推論パイプラインを指します (これは前の例で作成されたものです)。`input_data_path` で指定された Amazon S3 の場所には、ダウンロードして Spark ML モデルに送信する、CSV 形式の入力データが含まれます。変換ジョブが終了した後、`output_data_path` で指定された Amazon S3 の場所には、XGBoost モデルによって返された出力データが CSV 形式で含まれます。
```
import sagemaker
input_data_path = 's3://{}/{}/{}'.format(default_bucket, 'key', 'file_name')
output_data_path = 's3://{}/{}'.format(default_bucket, 'key')
transform_job = sagemaker.transformer.Transformer(
model_name = model_name,
instance_count = 1,
instance_type = 'ml.m4.xlarge',
strategy = 'SingleRecord',
assemble_with = 'Line',
output_path = output_data_path,
base_transform_job_name='inference-pipelines-batch',
sagemaker_session=sagemaker.Session(),
accept = CONTENT_TYPE_CSV)
transform_job.transform(data = input_data_path,
content_type = CONTENT_TYPE_CSV,
split_type = 'Line')
```
# 推論パイプラインのログとメトリクス
モニタリングは、Amazon SageMaker AI リソースの信頼性、可用性、パフォーマンスを維持する上で重要です。推論パイプラインのパフォーマンスをモニタリングし、トラブルシューティングするには、Amazon CloudWatch のログとエラーメッセージを使います。SageMaker AI が提供するモニタリングツールの詳細については、「[Amazon SageMaker AI での AWS リソースのモニタリング](monitoring-overview.md)」を参照してください。
## メトリクスを使用してマルチコンテナモデルをモニタリングする
推論パイプラインでマルチコンテナモデルをモニタリングするには、Amazon CloudWatch を使います。CloudWatch は、raw データを収集して、それを読み取り可能なほぼリアルタイムのメトリクスに変換します。SageMaker AI のトレーニングジョブとエンドポイントは CloudWatch のメトリクスとログを `AWS/SageMaker` 名前空間に書き込みます。
次の表に、以下のメトリクスとディメンションの一覧を示します。
+ エンドポイントの呼び出し
+ トレーニングジョブ、バッチ変換ジョブ、エンドポイントインスタンス
*ディメンション*は、メトリクスを一意に識別する名前と値のペアです。1 メトリクスあたり最大 10 ディメンションを割り当てることができます。CloudWatch を使ったモニタリングの詳細については、「[Amazon CloudWatch における Amazon SageMaker AI メトリクス](monitoring-cloudwatch.md)」を参照してください。
**エンドポイント呼び出しメトリクス**
`AWS/SageMaker` 名前空間には、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_InvokeEndpoint.html) への呼び出しからの次のリクエストメトリクスが含まれます。
メトリクスは 1 分間隔でレポートされます。
| メトリクス | 説明 |
| --- | --- |
| Invocation4XXErrors | `4xx` HTTP レスポンスコードを返したモデルの `InvokeEndpoint` リクエスト数。各 `4xx` レスポンスに、SageMaker AI は `1` を送信します。 単位: なし 有効な統計: `Average`、`Sum` |
| Invocation5XXErrors | `5xx` HTTP レスポンスコードを返したモデルの `InvokeEndpoint` リクエスト数。各 `5xx` レスポンスに、SageMaker AI は `1` を送信します。 単位: なし 有効な統計: `Average`、`Sum` |
| Invocations | モデルエンドポイントに送信された `number of InvokeEndpoint` リクエスト。 モデルエンドポイントに送信されたリクエストの合計数を得るには、`Sum` 統計を使用します。 単位: なし 有効な統計: `Sum`、`Sample Count` |
| InvocationsPerInstance | 各 `ProductionVariant` で `InstanceCount` によって正規化され、モデルに送信されたエンドポイント呼び出しの数。SageMaker AI は 1/`numberOfInstances` を値として各リクエストに送信します。ここで、`numberOfInstances` はリクエスト発生時のエンドポイントにある ProductionVariant のアクティブなインスタンスの数です。 単位: なし 有効な統計: `Sum` |
| ModelLatency | モデルの応答にかかった時間。これには、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかった時間と、コンテナ内で推論を完了するのにかかった時間が含まれます。ModelLatency は、推論パイプライン内のすべてのコンテナにかかった合計時間です。単位: マイクロ秒有効な統計: `Average`、`Sum`、`Min`、`Max`、Sample Count |
| OverheadLatency | オーバーヘッドのため、SageMaker AI によるクライアントリクエストへの応答にかかった時間に加算される時間。`OverheadLatency` は、SageMaker AI がリクエストを受信してからクライアントにレスポンスを返すまでの時間から `ModelLatency` を引いたものです。オーバーヘッドのレイテンシーは、リクエストとレスポンスのペイロードサイズ、リクエストの頻度、リクエストの認証、認可などの要因によって異なります。 単位: マイクロ秒 有効な統計: `Average`、`Sum`、`Min`、`Max`、`Sample Count` |
| ContainerLatency | SageMaker AI から見たときに、推論パイプラインコンテナが応答にかかった時間。ContainerLatency には、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかった時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。単位: マイクロ秒有効な統計: `Average`、`Sum`、`Min`、`Max`、`Sample Count` |
**エンドポイント呼び出しメトリクスのディメンション**
| ディメンション | 説明 |
| --- | --- |
| EndpointName, VariantName, ContainerName | 指定のエンドポイントおよび指定のバリアントの `ProductionVariant` のエンドポイント呼び出しメトリクスをフィルタリングします。 |
推論パイプラインエンドポイントの場合、CloudWatch は **[SageMaker AI]** 名前空間の下に **[エンドポイントのコンテナのメトリクス]** および **[エンドポイントのバリアントのメトリクス]** として、アカウント内のコンテナ単位のレイテンシーメトリクスを表示します。`ContainerLatency` メトリクスは、推定パイプラインに対してのみ表示されます。
![\[推論パイプラインの CloudWatch ダッシュボード。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/pipeline-endpoint-metrics.png)
レイテンシーメトリクスは、エンドポイントおよびコンテナごとに、コンテナ、エンドポイント、バリアント、メトリクスの名前を表示します。
![\[エンドポイントのレイテンシーメトリクス。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/pipeline-endpoint-metrics-details.png)
**トレーニングジョブ、バッチ変換ジョブ、およびエンドポイントインスタンスメトリクス**
`/aws/sagemaker/TrainingJobs`、`/aws/sagemaker/TransformJobs`、`/aws/sagemaker/Endpoints` 名前空間には、トレーニングジョブおよびエンドポイントインスタンスに関する以下のメトリクスが含まれています。
メトリクスは 1 分間隔でレポートされます。
| メトリクス | 説明 |
| --- | --- |
| CPUUtilization | インスタンスで実行中のコンテナによって使用されている CPU ユニットの割合。値の範囲は 0%～100% で、CPU の数で乗算されます。例えば、CPU が 4 つの場合、`CPUUtilization` は 0%～400% になります。 トレーニングジョブの場合、`CPUUtilization` はインスタンスで実行中のアルゴリズムコンテナの CPU 使用率です。 バッチ変換ジョブの場合、`CPUUtilization` はインスタンスで実行中の変換コンテナの CPU 使用率です。 マルチコンテナモデルの場合、`CPUUtilization` は、インスタンスで実行中のすべてのコンテナによる CPU 使用率の合計です。 エンドポイントのバリアントの場合、`CPUUtilization` は、インスタンスで実行中のすべてのコンテナの CPU 使用率の合計です。 単位: パーセント |
| MemoryUtilization | インスタンスで実行中のコンテナによって使用されているメモリの割合。この値は 0%～100% です。トレーニングジョブの場合、`MemoryUtilization` は、インスタンスで実行中のアルゴリズムコンテナによって使用されているメモリです。バッチ変換ジョブの変換の場合、`MemoryUtilization` は、インスタンスで実行中の変換コンテナによって使用されているメモリです。マルチコンテナモデルの場合、MemoryUtilization は、インスタンスで実行中のすべてのコンテナによって使用されているメモリの合計です。エンドポイントのバリアントの場合、`MemoryUtilization` は、インスタンスで実行中のすべてのコンテナによって使用されているメモリの合計です。単位: パーセント |
| GPUUtilization | インスタンスで実行中のコンテナによって使用されている GPU ユニットの割合です。`GPUUtilization` の範囲は 0%～100% で、GPU の数によって乗算されます。例えば、GPU が 4 つの場合、`GPUUtilization` は 0%～400% になります。 トレーニングジョブの場合、`GPUUtilization` は、インスタンスで実行中のアルゴリズムによって使用されている GPU です。 バッチ変換ジョブの場合、`GPUUtilization` は、インスタンスで実行中の変換コンテナによって使用されている GPU です。 マルチコンテナモデルの場合、`GPUUtilization` は、インスタンスで実行中のすべてのコンテナによって使用されている GPU の合計です。 エンドポイントのバリアントの場合、`GPUUtilization` は、インスタンスで実行中のすべてのコンテナによって使用されている GPU の合計です。 単位: パーセント |
| GPUMemoryUtilization | インスタンスで実行中のコンテナによって使用されている GPU メモリの割合。GPUMemoryUtilization 範囲は 0%～100% で、GPU の数によって乗算されます。例えば、GPU が 4 つの場合、`GPUMemoryUtilization` は 0%～400% になります。 トレーニングジョブの場合、`GPUMemoryUtilization` は、インスタンスで実行中のアルゴリズムコンテナで使用されている GPU メモリです。 バッチ変換ジョブの場合、`GPUMemoryUtilization` は、インスタンスで実行中の変換コンテナによって使用されている GPU メモリです。 マルチコンテナモデルの場合、`GPUMemoryUtilization` は、インスタンスで実行中のすべてのコンテナによって使用されている GPU の合計です。 エンドポイントのバリアントの場合、`GPUMemoryUtilization` は、インスタンスで実行中のすべてのコンテナによって使用されている GPU メモリの合計です。 単位: パーセント |
| DiskUtilization | インスタンスで実行中のコンテナによって使用されているディスク容量の割合。DiskUtilization の範囲は、0%～100% です。このメトリクスは、バッチ変換ジョブではサポートされていません。 トレーニングジョブの場合、`DiskUtilization` は、インスタンスで実行中のアルゴリズムコンテナで使用されているディスク容量です。 エンドポイントバリアントの場合、`DiskUtilization` は、インスタンスで実行中の提供されたすべてのコンテナによって使用されているディスク容量の合計です。 単位: パーセント |
**トレーニングジョブ、バッチ変換ジョブ、およびエンドポイントインスタンスメトリクスのディメンション**
| ディメンション | 説明 |
| --- | --- |
| Host | トレーニングジョブの場合、`Host` の形式は `[training-job-name]/algo-[instance-number-in-cluster]` になります。このディメンションを使用して、指定されたトレーニングジョブとインスタンスのインスタンスメトリクスをフィルタリングします。このディメンション形式は、`/aws/sagemaker/TrainingJobs` 名前空間にのみ存在します。 バッチ変換ジョブの場合、`Host` の形式は `[transform-job-name]/[instance-id]` になります。このディメンションを使用して、指定されたバッチ変換ジョブとインスタンスのインスタンスメトリクスをフィルタリングします。このディメンション形式は、`/aws/sagemaker/TransformJobs` 名前空間にのみ存在します。 エンドポイントの場合、`Host` の形式は `[endpoint-name]/[ production-variant-name ]/[instance-id]`なります。このディメンションを使用して、指定されたエンドポイント、バリアント、インスタンスのインスタンスメトリクスをフィルタリングします。このディメンション形式は、`/aws/sagemaker/Endpoints` 名前空間にのみ存在します。 |
トレーニングジョブ、エンドポイント、ノートブックインスタンスのライフサイクル設定のデバッグを支援するため、SageMaker AI はアルゴリズムコンテナ、モデルコンテナ、ノートブックインスタンスのライフサイクル設定が `stdout` や `stderr` に送信するすべての内容を Amazon CloudWatch Logs にも送信します。この情報を使用して、進行状況をデバッグおよび分析できます。
## ログを使用して推論パイプラインをモニタリングする
以下の表は、SageMaker AI が Amazon CloudWatch に送信するロググループとログストリームを示しています。
*ログストリーム*は、同じソースを共有する一連のログイベントです。CloudWatch に記録される個別のログソースは、個別にログストリーミングを構成します。*ロググループ*は、保持、モニタリング、アクセス制御について同じ設定を共有するログストリームのグループです。
**ログ**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/inference-pipeline-logs-metrics.html)
**注記**
SageMaker AI は、ライフサイクル設定を使ってノートブックインスタンスを作成すると、`/aws/sagemaker/NotebookInstances` ロググループを作成します。詳細については、「[LCC スクリプトを使用した SageMaker ノートブックインスタンスのカスタマイズ](notebook-lifecycle-config.md)」を参照してください。
SageMaker AI のログ記録の詳細については、「[Amazon SageMaker AI 用 CloudWatch Logs](logging-cloudwatch.md)」を参照してください。
# 推論パイプラインのトラブルシューティング
推論パイプラインの問題のトラブルシューティングを行うには、CloudWatch のログとエラーメッセージを使います。Amazon SageMaker AI の組み込みアルゴリズムを含むパイプラインでカスタム Docker イメージを使っている場合は、許可の問題も発生する可能性があります。必要な許可を付与するには、Amazon Elastic Container Registry (Amazon ECR) ポリシーを作成します。
**Topics**
+ [推論パイプラインの Amazon ECR アクセス許可のトラブルシューティングを行う](#inference-pipeline-troubleshoot-permissions)
+ [CloudWatch のログを使って SageMaker AI 推論パイプラインのトラブルシューティングを行う](#inference-pipeline-troubleshoot-logs)
+ [エラーメッセージを使用して推論パイプラインをトラブルシューティングする](#inference-pipeline-troubleshoot-errors)
## 推論パイプラインの Amazon ECR アクセス許可のトラブルシューティングを行う
[SageMaker AI 組み込みアルゴリズム](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html)を含むパイプラインでカスタム Docker イメージを使う場合は、[Amazon ECR ポリシー](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)が必要です。このポリシーは、SageMaker AI にイメージをプルする許可を、Amazon ECR リポジトリが付与できるようにします。このポリシーには以下のアクセス許可が含まれています。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "allowSageMakerToPull",
"Effect": "Allow",
"Principal": {
"Service": "sagemaker.amazonaws.com"
},
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "*"
}
]
}
```
------
## CloudWatch のログを使って SageMaker AI 推論パイプラインのトラブルシューティングを行う
SageMaker AI は、Amazon CloudWatch に推論パイプラインをデプロイするエンドポイントの、各コンテナのコンテナログを次のパスに発行します。
```
/aws/sagemaker/Endpoints/{EndpointName}/{Variant}/{InstanceId}/{ContainerHostname}
```
例えば、このエンドポイントのログは、次のロググループとストリームに発行されます。
```
EndpointName: MyInferencePipelinesEndpoint
Variant: MyInferencePipelinesVariant
InstanceId: i-0179208609ff7e488
ContainerHostname: MyContainerName1 and MyContainerName2
```
```
logGroup: /aws/sagemaker/Endpoints/MyInferencePipelinesEndpoint
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName1
logStream: MyInferencePipelinesVariant/i-0179208609ff7e488/MyContainerName2
```
*ログストリーム*は、同じソースを共有する一連のログイベントです。CloudWatch に記録される個別のログソースは、個別にログストリーミングを構成します。*ロググループ*は、保持、モニタリング、アクセス制御について同じ設定を共有するログストリームのグループです。
**ロググループとストリームを表示するには**
1. CloudWatch コンソールの [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) を開いてください。
1. ナビゲーションページで [**Logs**] (ログ) を選択します。
1. [**ロググループ**] で、**MyInferencePipelinesEndpoint** をフィルタリングします。
![\[推論パイプラインエンドポイントでフィルタリングされた CloudWatch ロググループ。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/pipeline-log-group-filter.png)
1. ログストリームを表示するには、CloudWatch の **[Log Groups]** (ロググループ) ページで [**MyInferencePipelinesEndpoint**] を選択し、**[Search Log Group]** (ロググループの検索) を選択します。
![\[推測パイプライン用の CloudWatch ログストリーム。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/pipeline-log-streams-2.png)
SageMaker AI が発行するログのリストについては、「[推論パイプラインのログとメトリクス](inference-pipeline-logs-metrics.md)」を参照してください。
## エラーメッセージを使用して推論パイプラインをトラブルシューティングする
推論パイプラインのエラーメッセージは、失敗したコンテナを示します。
SageMaker AI によるエンドポイントの呼び出し中にエラーが発生した場合、サービスは、失敗したコンテナを示す `ModelError` (エラーコード 424) を返します。リクエストペイロード (前のコンテナからのレスポンス) が 5 MB の制限を超えると、SageMaker AI は次のような詳細なエラーメッセージを返します。
MyContainerName1 からステータスコード 200 のレスポンスを受信しました。ただし、MyContainerName1 から MyContainerName2 へのリクエストペイロードは 6,000,000 バイトで、これは最大制限の 5 MB を超えています。
``
エンドポイントの作成中にコンテナが ping ヘルスチェックに失敗した場合は、SageMaker AI は `ClientError` を返し、最後のヘルスチェックで ping チェックに失敗したすべてのコンテナを示します。
# エンドポイントとリソースを削除する
エンドポイントを削除して料金の発生を停止します。
## エンドポイントを削除する
を使用してプログラムで AWS SDK for Python (Boto3)、 を使用して AWS CLI、または SageMaker AI コンソールを使用してインタラクティブにエンドポイントを削除します。
SageMaker AI は、エンドポイントの作成時にデプロイされたすべてのリソースを解放します。エンドポイントを削除しても、エンドポイント設定や SageMaker AI モデルは削除されません。エンドポイント設定と SageMaker AI モデルを削除する方法については、「[エンドポイント設定を削除する](#realtime-endpoints-delete-endpoint-config)」および「[モデルを削除する](#realtime-endpoints-delete-model)」を参照してください。
------
#### [ AWS SDK for Python (Boto3) ]
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) API を使用してエンドポイントを削除します。`EndpointName` フィールドにエンドポイントの名前を指定してください。
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint
sagemaker_client.delete_endpoint(EndpointName=endpoint_name)
```
------
#### [ AWS CLI ]
[https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint.html) コマンドを使用してエンドポイントを削除します。`endpoint-name` フラグにエンドポイントの名前を指定してください。
```
aws sagemaker delete-endpoint --endpoint-name
```
------
#### [ SageMaker AI Console ]
SageMaker AI コンソールを使用してインタラクティブにエンドポイントを削除します。
1. [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/) ナビゲーションメニューの SageMaker AI コンソールで、**[推論]** を選択します。
1. ドロップダウンメニューから **[エンドポイント]** を選択します。 AWS アカウントで作成されたエンドポイントのリストは、名前、Amazon リソースネーム (ARN)、作成時刻、ステータス、エンドポイントが最後に更新された時刻のタイムスタンプで表示されます。
1. 削除するエンドポイントを選択します。
1. 右上隅にある **[アクション]** ドロップダウンボタンを選択します。
1. **[削除]** を選択します。
------
## エンドポイント設定を削除する
を使用してプログラムで AWS SDK for Python (Boto3)、 を使用して AWS CLI、または SageMaker AI コンソールを使用してインタラクティブにエンドポイント設定を削除します。エンドポイント設定を削除しても、その設定を使用して作成されたエンドポイントは削除されません。エンドポイントを削除する方法については、「[エンドポイントを削除する](#realtime-endpoints-delete-endpoint)」を参照してください。
有効なエンドポイント、またはエンドポイントが更新または作成されている間は、使用中のエンドポイント設定を削除しないでください。アクティブまたは作成または更新中のエンドポイントのエンドポイント設定を削除すると、エンドポイントが使用しているインスタンスタイプが見えなくなる可能性があります。
------
#### [ AWS SDK for Python (Boto3) ]
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpointConfig.html) API を使用してエンドポイントを削除します。`EndpointConfigName` フィールドにエンドポイント設定の名前を指定してください。
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
endpoint_config_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
オプションで、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) API を使用して、モデルの名前やデプロイされたモデルに関連付けられたエンドポイント設定の名前など、デプロイされたモデルの名前 (プロダクションバリアント) に関する情報を返すことができます。`EndpointConfigName` フィールドにエンドポイントの名前を指定してください。
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
endpoint_config_name = response['ProductionVariants'][0]['EndpointConfigName']
# Delete endpoint configuration
sagemaker_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
```
`DescribeEndpointConfig` によって返されるその他のレスポンス要素の詳細については、「[SageMaker API リファレンスガイド](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html)」の「[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)」を参照してください。
------
#### [ AWS CLI ]
[https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-endpoint-config.html) コマンドを使用してエンドポイント設定を削除します。`endpoint-config-name` フラグにエンドポイント設定の名前を指定してください。
```
aws sagemaker delete-endpoint-config \
--endpoint-config-name
```
オプションで、[https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) コマンドを使用して、モデルの名前やデプロイされたモデルに関連付けられたエンドポイント設定の名前など、デプロイされたモデルの名前 (プロダクションバリアント) に関する情報を返すことができます。`endpoint-config-name` フラグにエンドポイントの名前を指定してください。
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
これにより JSON レスポンスが返されます。コピーアンドペーストや JSON パーサーを使用するか、または JSON 解析用に構築されたツールを使用して、エンドポイントに関連付けられたエンドポイント設定名を取得できます。
------
#### [ SageMaker AI Console ]
SageMaker AI コンソールを使用してインタラクティブにエンドポイント設定を削除します。
1. [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/) ナビゲーションメニューの SageMaker AI コンソールで、**[推論]** を選択します。
1. ドロップダウンメニューから **[エンドポイント設定]** を選択します。 AWS アカウントで作成されたエンドポイント設定のリストは、名前、Amazon リソースネーム (ARN)、および作成時間別に表示されます。
1. 削除するエンドポイント設定を選択します。
1. 右上隅にある **[アクション]** ドロップダウンボタンを選択します。
1. **[削除]** を選択します。
------
## モデルを削除する
、 AWS SDK for Python (Boto3)、または SageMaker AI コンソールを使用してインタラクティブに AWS CLIプログラムで SageMaker AI モデルを削除します。SageMaker AI モデルを削除すると、SageMaker AI で作成されたモデルエントリのみが削除されます。モデルを削除しても、モデルアーティファクト、推論コード、モデル作成時に指定した IAM ロールは削除されません。
------
#### [ AWS SDK for Python (Boto3) ]
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html) API を使用して SageMaker AI モデルを削除します。`ModelName` フィールドにモデルの名前を指定してください。
```
import boto3
# Specify your AWS Region
aws_region=''
# Specify the name of your endpoint configuration
model_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Delete model
sagemaker_client.delete_model(ModelName=model_name)
```
オプションで、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) API を使用して、モデルの名前やデプロイされたモデルに関連付けられたエンドポイント設定の名前など、デプロイされたモデルの名前 (プロダクションバリアント) に関する情報を返すことができます。`EndpointConfigName` フィールドにエンドポイントの名前を指定してください。
```
# Specify the name of your endpoint
endpoint_name=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Store DescribeEndpointConfig response into a variable that we can index in the next step.
response = sagemaker_client.describe_endpoint_config(EndpointConfigName=endpoint_name)
# Delete endpoint
model_name = response['ProductionVariants'][0]['ModelName']
sagemaker_client.delete_model(ModelName=model_name)
```
`DescribeEndpointConfig` によって返されるその他のレスポンス要素の詳細については、「[SageMaker API リファレンスガイド](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Operations_Amazon_SageMaker_Service.html)」の「[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html)」を参照してください。
------
#### [ AWS CLI ]
[https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/delete-model.html) コマンドを使用して SageMaker AI モデルを削除します。`model-name` フラグにモデルの名前を指定してください。
```
aws sagemaker delete-model \
--model-name
```
オプションで、[https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/describe-endpoint-config.html) コマンドを使用して、モデルの名前やデプロイされたモデルに関連付けられたエンドポイント設定の名前など、デプロイされたモデルの名前 (プロダクションバリアント) に関する情報を返すことができます。`endpoint-config-name` フラグにエンドポイントの名前を指定してください。
```
aws sagemaker describe-endpoint-config --endpoint-config-name
```
これにより JSON レスポンスが返されます。コピーアンドペーストや JSON パーサーを使用するか、または JSON 解析用に構築されたツールを使用して、そのエンドポイントに関連付けられたモデルの名前を取得できます。
------
#### [ SageMaker AI Console ]
SageMaker AI コンソールを使用してインタラクティブに SageMaker AI モデルを削除します。
1. [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/) ナビゲーションメニューの SageMaker AI コンソールで、**[推論]** を選択します。
1. ドロップダウンメニューから **[モデル]** を選択します。 AWS アカウントで作成されたモデルのリストは、名前、Amazon リソースネーム (ARN)、および作成時刻で表示されます。
1. 削除するモデルを選択します。
1. 右上隅にある **[アクション]** ドロップダウンボタンを選択します。
1. **[Delete]** (削除) をクリックします。
------
# Amazon SageMaker AI モデルの自動スケーリング
Amazon SageMaker AI では、ホストモデルの自動的なスケーリング (オートスケーリング) がサポートされています。*自動スケーリング*は、ワークロードの変動に応じて、モデルにプロビジョニングされるインスタンスの数を動的に調整します。ワークロードが増加すると、自動スケーリングはより多くのインスタンスをオンラインにします。ワークロードが減少すると、自動スケーリングは使用していないプロビジョニングされたインスタンスに対して支払いが発生しないように、不要なインスタンスを削除します。
**Topics**
+ [自動スケーリングポリシーの概要](endpoint-auto-scaling-policy.md)
+ [自動スケーリングの前提条件](endpoint-auto-scaling-prerequisites.md)
+ [コンソールを使用してモデルの自動スケーリングを設定する](endpoint-auto-scaling-add-console.md)
+ [モデルの登録](endpoint-auto-scaling-add-policy.md)
+ [スケーリングポリシーを定義する](endpoint-auto-scaling-add-code-define.md)
+ [スケーリングポリシーを適用する](endpoint-auto-scaling-add-code-apply.md)
+ [スケーリングポリシーを編集する手順](endpoint-auto-scaling-edit.md)
+ [スケーリングポリシーを一時的に無効にする](endpoint-auto-scaling-suspend-scaling-activities.md)
+ [スケーリングポリシーを削除する](endpoint-auto-scaling-delete.md)
+ [スケーリングアクティビティを記述してスケーリングアクティビティのステータスを確認する](endpoint-scaling-query-history.md)
+ [エンドポイントをゼロインスタンスにスケールする](endpoint-auto-scaling-zero-instances.md)
+ [自動スケーリング設定の負荷テスト](endpoint-scaling-loadtest.md)
+ [CloudFormation を使用してスケーリングポリシーを作成する](endpoint-scaling-cloudformation.md)
+ [自動スケーリングを使用するエンドポイントを更新する](endpoint-scaling-update.md)
+ [自動スケーリングに設定されたエンドポイントを削除する](endpoint-delete-with-scaling.md)
# 自動スケーリングポリシーの概要
自動スケーリングを使用するには、実際のワークロードに応じて本番稼働用バリアントのインスタンス数を追加および削除するスケーリングポリシーを定義します。
ワークロードの変動に合わせて自動的にスケーリングするには、ターゲット追跡ポリシーとステップスケーリングポリシーの 2 つのオプションがあります。
大半のケースで推奨されるのはターゲット追跡スケーリングポリシーです。ターゲット追跡では、Amazon CloudWatch メトリクスとターゲット値を選択します。自動スケーリングは、スケーリングポリシーの CloudWatch アラームを作成および管理し、メトリクスとターゲット値に基づいてスケーリング調整値を計算します。ポリシーは、指定されたターゲット値、またはそれに近い値にメトリクスを維持するために、必要に応じてインスタンスを追加または削除します。たとえば、事前定義された `InvocationsPerInstance` メトリクスのターゲット値を 70 に設定すると、`InvocationsPerInstance` を 70 または 70 近くに維持できます。詳細については、[Application Auto Scaling ユーザーガイド](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html)の Target Tracking Scaling Policies を参照してください。
ステップスケーリングは、デプロイするインスタンスの数や条件を指定するなど、高度な設定が必要な場合に使用できます。たとえば、エンドポイントがゼロアクティブインスタンスからスケールアウトできるようにする場合は、ステップスケーリングを使用する必要があります。ステップスケーリングポリシーの概要とその仕組みについては、「[Application Auto Scaling ユーザー ガイド](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html)」の「ステップスケーリングポリシー」を参照してください。
ターゲット追跡スケーリングポリシーを作成するには、以下を指定します。
+ **メトリクス** — インスタンスあたりの平均呼び出し数など、追跡する CloudWatch メトリクス。
+ **ターゲット値** — 1 分ごとにインスタンスあたり 70 回の呼び出しなど、メトリクスのターゲット値。
事前定義されたメトリクスまたはカスタムメトリクスのいずれかを使用して、ターゲット追跡スケーリングポリシーを作成できます。事前定義されたメトリクスは列挙型で定義されるため、それをコード内に名前で指定するか、SageMaker AI コンソールで使用できます。代わりに、 AWS CLI または Application Auto Scaling API を使用し、事前定義されたメトリクスまたはカスタムメトリクスに基づいてターゲット追跡スケーリングポリシーを適用することもできます。
スケーリングアクティビティは、容量の急激な変動を防ぐため、クールダウン期間を設けて実行されることに注意してください。オプションでスケーリングポリシーのクールダウン期間を設定できます。
自動スケーリングの主な概念については、以下のセクションを参照してください。
## スケジュールベースのスケーリング
スケジュールされたアクションを作成して、特定の時刻にスケーリングアクティビティを実行することもできます。スケジュールされたアクションは、一度だけスケールする、または定期的なスケジュールに従ってスケールするものを作成できます。スケジュールされたアクションが実行された後も、スケーリングポリシーは、ワークロードの変動が発生したときに動的にスケーリングするかどうかの決定を引き続き行うことができます。スケジュールされたスケーリングは、 AWS CLI または Application Auto Scaling API からのみ管理できます。詳細については、「*Application Auto Scaling ユーザーガイド*」の「[スケジュールされたスケーリング](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html)」を参照してください。
## 最小スケーリング制限と最大スケーリング制限
自動スケーリングを設定するときは、スケーリングポリシーを作成する前にスケーリング制限を指定する必要があります。最小値と最大値の制限を個別に設定します。
最小値は 1 以上で、最大値で指定された値以下である必要があります。
最大値は、最小数に指定された値以上である必要があります。SageMaker AI の自動スケーリングでは、この値に制限は適用されません。
通常のトラフィックに必要なスケーリング制限を決定するには、モデルに対するトラフィックの予想レートで自動スケーリングの設定をテストします。
バリアントのトラフィックがゼロになった場合、SageMaker AI は、指定されたインスタンスの最小数に自動的にスケールインします。この場合、SageMaker AI からは値がゼロのメトリクスが出力されます。
最小容量と最大容量を指定するには、次の 3 つのオプションがあります。
1. コンソールを使用して、**[最小インスタンス数]** と **[最大インスタンス数]** の設定を更新します。
1. register-scalable-target コマンドを実行するときは、 AWS CLI を使用し、 `--min-capacity`オプションと `--max-capacity`オプションを含めます。 [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)
1. [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html) API を呼び出し、`MinCapacity` および `MaxCapacity` パラメータを指定します。
**ヒント**
最小値を増やすことで手動でスケールアウトすることも、最大値を減らすことで手動でスケールインすることもできます。
## クールダウン期間
*クールダウン期間*は、モデルのスケールイン (容量の削減) またはスケールアウト (容量の増加) 時に、オーバースケーリングを防ぐために使用されます。これは、この期間が終了するまで、後続のスケーリングアクティビティを遅らせるものです。つまり、スケールインのリクエストについてはインスタンスの削除が、スケールアウトのリクエストについてはインスタンスの作成が停止されます。詳細については、「*Application Auto Scaling ユーザーガイド*」の「[Define cooldown periods](https://docs.aws.amazon.com/autoscaling/application/userguide/target-tracking-scaling-policy-overview.html#target-tracking-cooldown)」を参照してください。
スケーリングポリシーのクールダウン期間はお客様が設定します。
スケールインやスケールアウトのクールダウン期間を指定しない場合、スケーリングポリシーではデフォルト値 (それぞれ 300 秒) が使用されます。
スケーリングの設定をテストしたときに、インスタンスが追加または削除されるペースが速すぎる場合は、この値を増やすことを検討してください。この動作は、モデルへのトラフィックに大量のスパイクがある場合や、バリアントに対して複数のスケーリングポリシーを定義した場合に見られます。
インスタンスが追加されるペースが増加したトラフィックに対処するのに十分でない場合は、この値を減らすことを検討してください。
## 関連リソース
自動スケーリングの設定の詳細については、次のリソースを参照してください。
+ AWS CLI コマンドリファレンスの [application-autoscaling](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling) セクション
+ Application Auto Scaling API リファレンス[https://docs.aws.amazon.com/autoscaling/application/APIReference/](https://docs.aws.amazon.com/autoscaling/application/APIReference/)
+ アプリケーション Auto Scaling ユーザーガイド[https://docs.aws.amazon.com/autoscaling/application/userguide/](https://docs.aws.amazon.com/autoscaling/application/userguide/)
**注記**
SageMaker AI では最近、リアルタイム推論エンドポイント上に構築された新しい推論機能を導入しました。エンドポイントのインスタンスタイプと初期インスタンス数を定義するエンドポイント設定を使用して SageMaker AI エンドポイントを作成します。次に、推論コンポーネントを作成します。これは、モデルをエンドポイントにデプロイするために使用できる SageMaker AI ホスティングオブジェクトです。推論コンポーネントのスケーリングの詳細については、 AWS ブログの[SageMaker AI が新しい推論機能を追加して、基盤モデルのデプロイコストとレイテンシーを削減](https://aws.amazon.com/blogs/aws/amazon-sagemaker-adds-new-inference-capabilities-to-help-reduce-foundation-model-deployment-costs-and-latency/)し、[SageMaker AI の最新機能を使用してモデルデプロイコストを平均 50% 削減](https://aws.amazon.com/blogs/machine-learning/reduce-model-deployment-costs-by-50-on-average-using-sagemakers-latest-features/)する」を参照してください。
# 自動スケーリングの前提条件
自動スケーリングを使用するには、事前に Amazon SageMaker AI モデルのエンドポイントを作成しておく必要があります。同じエンドポイントに複数のモデルバージョンを持つことができます。各モデルは、[本番稼働用 (モデル) バリアント](model-ab-testing.md)と呼ばれます。モデルのエンドポイントのデプロイの詳細については、「[SageMaker AI ホスティングサービスにモデルをデプロイする](ex1-model-deployment.md#ex1-deploy-model)」を参照してください。
モデルの Auto Scaling を有効にするには、Application Auto Scaling API を使用して SageMaker AI コンソール、 AWS Command Line Interface (AWS CLI)、または AWS SDK を使用できます。
+ モデルのスケーリングを初めて設定する場合は、[コンソールを使用してモデルの自動スケーリングを設定する](endpoint-auto-scaling-add-console.md)ことをお勧めします。
+ AWS CLI または Application Auto Scaling API を使用する場合、フローはモデルをスケーラブルターゲットとして登録し、スケーリングポリシーを定義して適用することです。SageMaker AI コンソールを開き、ナビゲーションペインの **[推論]** で **[エンドポイント]** を選択します。モデルのエンドポイント名を探して選択し、バリアント名を見つけます。モデルの自動スケーリングを有効にするには、エンドポイント名とバリアント名の両方を指定する必要があります。
自動スケーリングは、Amazon SageMaker AI、Amazon CloudWatch、および Application Auto Scaling API の組み合わせによって可能になります。最低限必要なアクセス許可の詳細については、「*Application Auto Scaling ユーザーガイド*」の「[Application Auto Scaling identity-based policy examples](https://docs.aws.amazon.com/autoscaling/application/userguide/security_iam_id-based-policy-examples.html)」を参照してください。
`SagemakerFullAccessPolicy` IAM ポリシーには、自動スケーリングを実行するために必要なすべての IAM アクセス許可が付与されています。SageMaker AI IAM アクセス許可の詳細については、「[SageMaker AI 実行ロールの使用方法](sagemaker-roles.md)」を参照してください。
独自のアクセス許可ポリシーを管理している場合は、次のアクセス許可を含める必要があります。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeEndpoint",
"sagemaker:DescribeEndpointConfig",
"sagemaker:UpdateEndpointWeightsAndCapacities"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"application-autoscaling:*"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:CreateServiceLinkedRole",
"Resource": "arn:aws:iam::*:role/aws-service-role/sagemaker.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint",
"Condition": {
"StringLike": { "iam:AWSServiceName": "sagemaker.application-autoscaling.amazonaws.com" }
}
},
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricAlarm",
"cloudwatch:DescribeAlarms",
"cloudwatch:DeleteAlarms"
],
"Resource": "*"
}
]
}
```
------
## サービスにリンクされたロール
自動スケーリングは、サービスにリンクされたロール `AWSServiceRoleForApplicationAutoScaling_SageMakerEndpoint` を使用します。このサービスにリンクされたロールは、Application Auto Scaling に対して、ポリシーのアラームの記述、現在の容量レベルのモニタリング、およびターゲットリソースのスケーリングを行うためのアクセス許可を付与します。このロールは自動的に作成されます。この自動ロール作成が正常に行われるには、`iam:CreateServiceLinkedRole` アクションへのアクセス許可が必要です。詳細については、*アプリケーション Auto Scaling ユーザーガイド*の「[サービスにリンクされたロール](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html)」を参照してください。
# コンソールを使用してモデルの自動スケーリングを設定する
**モデルの自動スケーリングを設定するには (コンソール)**
1. Amazon SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) を開きます。
1. ナビゲーションペインで **[推論]** を選択し、**[エンドポイント]** を選択します。
1. エンドポイントを選択し、**[エンドポイントのランタイム設定]** でバリアントを選択します。
1. [**Auto Scaling の設定**] を選択します。
1. **[バリアントの自動スケーリングの設定]** ページの **[バリアントの自動スケーリング]** で、以下を実行します。
1. **[最小インスタンス数]** に、スケーリングポリシーが維持する必要があるインスタンスの最小数を入力します。少なくとも 1 つのインスタンスが必要です
1. **[最大インスタンス数]** に、スケーリングポリシーが維持する必要があるインスタンスの最大数を入力します。
1. **[組み込みのスケーリングポリシー]** で、以下を実行します。
1. **[ターゲットメトリクス]** については、メトリクスに `SageMakerVariantInvocationsPerInstance` が自動的に選択され、変更できません。
1. **[ターゲット値]** については、モデルの 1 分あたりのインスタンスごとの平均呼び出し回数を入力します。この値を確認するには、「[負荷テスト](endpoint-scaling-loadtest.md)」のガイドラインに従います。
1. **[スケールインのクールダウン (秒)]** と **[スケールアウトのクールダウン (秒)]** に、それぞれのクールダウン期間の秒数を入力します。
1. (オプション) トラフィックが減少したときに自動スケーリングでインスタンスが終了されないようにするには、**[スケールインの無効化]** を選択します。
1. **[保存]** を選択します。
この手順では、Application Auto Scaling を使用してモデルをスケーラブルなターゲットとして登録します。モデルを登録するときに、Application Auto Scaling は検証チェックを実行して、次のことを確認します。
+ モデルが存在する
+ アクセス許可が十分である
+ T2 などのパフォーマンスをバースト可能なインスタンスであるインスタンスを持つバリアントを登録しない
**注記**
T2 などのバースト可能なインスタンスは増加したワークロード下でのキャパシティー増に既に対応しているため、SageMaker AI ではそれらのインスタンスの自動スケーリングはサポートしていません。バーストパフォーマンスインスタンスの詳細については、「[Amazon EC2 インスタンスタイプ](https://aws.amazon.com/ec2/instance-types/)」を参照してください。
# モデルの登録
モデルにスケーリングポリシーを追加する前に、まずモデルを自動スケーリングに登録し、モデルのスケーリング制限を定義する必要があります。
次の手順では、 AWS Command Line Interface () または Application Auto Scaling API を使用して自動スケーリング用のモデル (本番稼働用バリアントAWS CLI) を登録する方法について説明します。
**Topics**
+ [モデルの登録 (AWS CLI)](#endpoint-auto-scaling-add-cli)
+ [モデルの登録 (Application Auto Scaling API)](#endpoint-auto-scaling-add-api)
## モデルの登録 (AWS CLI)
本番稼働用バリアントを登録するには、[register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html) コマンドを次のパラメータとともに使用します。
+ `--service-namespace` - この値は `sagemaker` に設定します。
+ `--resource-id` - モデルのリソース識別子 (具体的には本番稼働用バリアント)。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子は本番稼働用バリアントの名前です。例えば、`endpoint/my-endpoint/variant/my-variant`。
+ `--scalable-dimension` - この値は `sagemaker:variant:DesiredInstanceCount` に設定します。
+ `--min-capacity` - インスタンスの最小数。この値は 1 以上、および `max-capacity` に指定された値以下である必要があります。
+ `--max-capacity` - インスタンスの最大数。この値は 1 以上、および `min-capacity` に指定された値以上である必要があります。
**Example**
次の例では、`my-endpoint` エンドポイントで実行されている `my-variant` という名前のバリアントを登録して、1 ～ 8 個のインスタンスを持つように動的にスケーリングする方法を示します。
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--min-capacity 1 \
--max-capacity 8
```
## モデルの登録 (Application Auto Scaling API)
Application Auto Scaling でモデルを登録するには、次のパラメータを指定して Application Auto Scaling API アクション [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html) を使用します。
+ `ServiceNamespace` - この値は `sagemaker` に設定します。
+ `ResourceID` - 本番稼働用バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例: `endpoint/my-endpoint/variant/my-variant`。
+ `ScalableDimension` - この値は `sagemaker:variant:DesiredInstanceCount` に設定します。
+ `MinCapacity` - インスタンスの最小数。この値は 1 以上、および `MaxCapacity` に指定された値以下である必要があります。
+ `MaxCapacity` - インスタンスの最大数。この値は 1 以上、および `MinCapacity` に指定された値以上である必要があります。
**Example**
次の例では、`my-endpoint` エンドポイントで実行されている `my-variant` という名前のバリアントを登録して、1 ～ 8 個のインスタンスを使用するように動的にスケーリングする方法を示します。
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"MinCapacity": 1,
"MaxCapacity": 8
}
```
# スケーリングポリシーを定義する
スケーリングポリシーをモデルに追加する前に、ポリシー設定を JSON ブロックとしてテキストファイルに保存します。このテキストファイルは、 AWS Command Line Interface (AWS CLI) または Application Auto Scaling API を呼び出すときに使用します。適切な CloudWatch メトリクスを選択することで、スケーリングを最適化できます。ただし、本番環境でカスタムメトリクスを使用する前に、カスタムメトリクスを使用して自動スケーリングをテストする必要があります。
**Topics**
+ [事前定義されたメトリクスを指定する (CloudWatch メトリクス: InvocationsPerInstance)](#endpoint-auto-scaling-add-code-predefined)
+ [高解像度の事前定義済みメトリクスを指定する (CloudWatch メトリクス: ConcurrentRequestsPerModel と ConcurrentRequestsPerCopy )](#endpoint-auto-scaling-add-code-high-res)
+ [カスタムメトリクスを定義する (CloudWatch メトリクス: CPUUtilization)](#endpoint-auto-scaling-add-code-custom)
+ [カスタムメトリクスを定義する (CloudWatch メトリクス: ExplanationsPerInstance)](#endpoint-auto-scaling-online-explainability)
+ [クールダウン期間を指定する](#endpoint-auto-scaling-add-code-cooldown)
このセクションでは、ターゲット追跡スケーリングポリシーの設定例を示します。
## 事前定義されたメトリクスを指定する (CloudWatch メトリクス: InvocationsPerInstance)
**Example**
以下は、インスタンスあたりの平均呼び出し数を 70 に維持するバリアントのターゲット追跡ポリシーの設定例です。この設定を `config.json` という名前のファイルに保存してください。
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
```
詳細については、*Application Auto Scaling API Reference* の「[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)」を参照してください。
## 高解像度の事前定義済みメトリクスを指定する (CloudWatch メトリクス: ConcurrentRequestsPerModel と ConcurrentRequestsPerCopy )
次の高解像度の CloudWatch メトリクスを使用すると、モデルが受信するたくさんの同時リクエストのスケーリングポリシーを設定できます。
**ConcurrentRequestsPerModel**
モデルコンテナが受信する同時リクエストの数。
**ConcurrentRequestsPerCopy**
推論コンポーネントが受信する同時リクエストの数。
これらのメトリクスは、モデルコンテナが処理する同時リクエスト (コンテナ内でキューに入れられたリクエストを含む) の数を追跡します。トークンのストリームとして推論レスポンスを送信するモデルの場合、これらのメトリクスは、モデルがリクエストの最後のトークンを送信するまで、各リクエストを追跡します。
このような高解像度メトリクスは、標準の CloudWatch メトリクスよりも頻繁にデータを出力します。`InvocationsPerInstance` メトリクスなどの標準メトリクスは、1 分に 1 回データを出力しますが、これらの高解像度メトリクスは 10 秒ごとにデータを出力します。したがって、モデルへの同時トラフィックが増加するにつれて、ポリシーは標準メトリクスよりもはるかに早くスケールアウトすることで対応します。ただし、モデルへのトラフィックが減少すると、ポリシーは標準メトリクスと同じ速度でスケールインします。
以下は、モデルあたりの同時リクエスト数が 5 を超えた場合にインスタンスを追加するターゲット追跡ポリシーの設定例です。この設定を `config.json` という名前のファイルに保存してください。
```
{
"TargetValue": 5.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantConcurrentRequestsPerModelHighResolution"
}
}
```
推論コンポーネントを使用して複数のモデルを同じエンドポイントにデプロイする場合は、同等のポリシーを作成できます。この場合は、`PredefinedMetricType` を `SageMakerInferenceComponentConcurrentRequestsPerCopyHighResolution` に設定します。
詳細については、*Application Auto Scaling API Reference* の「[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)」を参照してください。
## カスタムメトリクスを定義する (CloudWatch メトリクス: CPUUtilization)
カスタムメトリクスを使用してターゲット追跡スケーリングポリシーを作成するには、メトリクスの名前、名前空間、単位、統計、0 以上のディメンションを指定します。ディメンションには、そのディメンションの名前と値を含みます。容量に比例して変化する本番稼働用バリアントのメトリクスを使用できます。
**Example**
次の設定例は、カスタムメトリクスを使用したターゲット追跡スケーリングポリシーを示しています。このポリシーは、すべてのインスタンスの平均 CPU 使用率が 50% であることに基づいてバリアントをスケーリングします。この設定を `config.json` という名前のファイルに保存してください。
```
{
"TargetValue": 50.0,
"CustomizedMetricSpecification":
{
"MetricName": "CPUUtilization",
"Namespace": "/aws/sagemaker/Endpoints",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Average",
"Unit": "Percent"
}
}
```
詳細については、*Application Auto Scaling API リファレンス*の「[CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)」を参照してください。
## カスタムメトリクスを定義する (CloudWatch メトリクス: ExplanationsPerInstance)
エンドポイントでオンライン説明可能性をアクティブ化すると、バリアントのインスタンスごとに、1 分あたりに説明されたレコード数の平均を出力する `ExplanationsPerInstance` メトリクスが出力されます。レコードを説明するリソース使用率は、レコードを予測する場合と大きく異なることがあります。オンライン説明可能性をアクティブ化したエンドポイントのターゲット追跡スケーリングには、このメトリクスを使用することを強くお勧めします。
スケーラブルなターゲットに対して複数のターゲット追跡ポリシーを作成できます。「[事前定義されたメトリクスを指定する (CloudWatch メトリクス: InvocationsPerInstance)](#endpoint-auto-scaling-add-code-predefined)」セクションの `InvocationsPerInstance` ポリシーを、(`ExplanationsPerInstance` ポリシーに加えて) 追加することを検討してください。`EnableExplanations` パラメータに設定されたしきい値が原因でほとんどの呼び出しで説明が返されない場合、エンドポイントは `InvocationsPerInstance` ポリシーを選択できます。多数の説明がある場合、エンドポイントは `ExplanationsPerInstance` ポリシーを使用できます。
**Example**
次の設定例は、カスタムメトリクスを使用したターゲット追跡スケーリングポリシーを示しています。このスケーリングポリシーは、各インスタンスの `ExplanationsPerInstance` メトリクスが 20 になるようにバリアントインスタンスの数を調整します。この設定を `config.json` という名前のファイルに保存してください。
```
{
"TargetValue": 20.0,
"CustomizedMetricSpecification":
{
"MetricName": "ExplanationsPerInstance",
"Namespace": "AWS/SageMaker",
"Dimensions": [
{"Name": "EndpointName", "Value": "my-endpoint" },
{"Name": "VariantName","Value": "my-variant"}
],
"Statistic": "Sum"
}
}
```
詳細については、*Application Auto Scaling API リファレンス*の「[CustomizedMetricSpecification](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_CustomizedMetricSpecification.html)」を参照してください。
## クールダウン期間を指定する
必要に応じて、`ScaleOutCooldown` または `ScaleInCooldown` パラメータを指定してターゲット追跡スケーリングポリシーでクールダウン期間を定義できます。
**Example**
以下は、インスタンスあたりの平均呼び出し数を 70 に維持するバリアントのターゲット追跡ポリシーの設定例です。このポリシー構成では、スケールインのクールダウン期間が 10 分間 (600 秒)、スケールアウトのクールダウン期間が 5 分間 (300 秒) に設定されます。この設定を `config.json` という名前のファイルに保存してください。
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"ScaleInCooldown": 600,
"ScaleOutCooldown": 300
}
```
詳細については、*Application Auto Scaling API Reference* の「[TargetTrackingScalingPolicyConfiguration](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)」を参照してください。
# スケーリングポリシーを適用する
モデルを登録してスケーリングポリシーを定義したら、そのスケーリングポリシーを登録されたモデルに適用します。このセクションでは、 AWS Command Line Interface (AWS CLI) または Application Auto Scaling API を使用してスケーリングポリシーを適用する方法を示します。
**Topics**
+ [ターゲット追跡スケーリングポリシーを適用する (AWS CLI)](#endpoint-auto-scaling-add-code-apply-cli)
+ [スケーリングポリシーを適用する (Application Auto Scaling API)](#endpoint-auto-scaling-add-code-apply-api)
## ターゲット追跡スケーリングポリシーを適用する (AWS CLI)
モデルにスケーリングポリシーを適用するには、次のパラメータを指定して [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html) AWS CLI コマンドを使用します。
+ `--policy-name` - スケーリングポリシーの名前。
+ `--policy-type` - この値は `TargetTrackingScaling` に設定します。
+ `--resource-id` - バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例えば、`endpoint/my-endpoint/variant/my-variant`。
+ `--service-namespace` - この値は `sagemaker` に設定します。
+ `--scalable-dimension` - この値は `sagemaker:variant:DesiredInstanceCount` に設定します。
+ `--target-tracking-scaling-policy-configuration` - モデルに使用するターゲット追跡スケーリングポリシーの設定。
**Example**
次の例では、`my-endpoint` エンドポイントで実行されている `my-variant` という名前のバリアントに `my-scaling-policy` という名前のターゲット追跡スケーリングポリシーを適用します。`--target-tracking-scaling-policy-configuration` オプションで、以前に作成した `config.json` ファイルを指定します。
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--target-tracking-scaling-policy-configuration file://config.json
```
## スケーリングポリシーを適用する (Application Auto Scaling API)
Application Auto Scaling API を使用してスケーリングポリシーをバリアントに適用するには、次のパラメータを指定して Application Auto Scaling API アクション [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html) を使用します。
+ `PolicyName` - スケーリングポリシーの名前。
+ `ServiceNamespace` - この値は `sagemaker` に設定します。
+ `ResourceID` - バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例えば、`endpoint/my-endpoint/variant/my-variant`。
+ `ScalableDimension` - この値は `sagemaker:variant:DesiredInstanceCount` に設定します。
+ `PolicyType` - この値は `TargetTrackingScaling` に設定します。
+ `TargetTrackingScalingPolicyConfiguration` - バリアントに使用するターゲット追跡スケーリングポリシー設定。
**Example**
次の例では、`my-endpoint` エンドポイントで実行されている `my-variant` という名前のバリアントに `my-scaling-policy` という名前のターゲット追跡スケーリングポリシーを適用します。このポリシー設定では、インスタンスあたりの平均呼び出し数が 70 に維持されます。
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration": {
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
}
}
}
```
# スケーリングポリシーを編集する手順
スケーリングポリシーを作成した後、名前以外のすべての設定を更新できます。
でターゲット追跡スケーリングポリシーを編集するには AWS マネジメントコンソール、 に使用したのと同じ手順を使用します[コンソールを使用してモデルの自動スケーリングを設定する](endpoint-auto-scaling-add-console.md)。
AWS CLI または Application Auto Scaling API を使用して、新しいスケーリングポリシーを作成するのと同じ方法でスケーリングポリシーを編集できます。詳細については、「[スケーリングポリシーを適用する](endpoint-auto-scaling-add-code-apply.md)」を参照してください。
# スケーリングポリシーを一時的に無効にする
自動スケーリングを設定した後、スケーリングポリシー (動的スケーリング) による干渉を受けずに問題を調査する必要がある場合は、次のオプションがあります。
+ CLI コマンド [register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html) または API アクション [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html) を呼び出して `DynamicScalingInSuspended` と `DynamicScalingOutSuspended` の両方にブール値を指定することで、スケーリングアクティビティを一時的に停止してから再開します。
**Example**
次の例は、`my-endpoint` エンドポイントで実行されている `my-variant` という名前のバリアントのスケーリングポリシーを一時停止する方法を示しています。
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant \
--scalable-dimension sagemaker:variant:DesiredInstanceCount \
--suspended-state '{"DynamicScalingInSuspended":true,"DynamicScalingOutSuspended":true}'
```
+ ポリシーのスケールイン部分を無効にして、特定のターゲット追跡スケーリングポリシーでバリアントのスケールインが行われないようにします。この方法を使うと、スケーリングポリシーによってインスタンスが削除されることがなくなる一方で、インスタンスの作成は必要に応じて行われます。
CLI コマンド [put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html) または API アクション [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html) を使って `DisableScaleIn` のブール値を指定してポリシーを編集することで、スケールインアクティビティを一時的に無効にしてから有効にします。
**Example**
以下は、スケールアウトするがスケールインしないスケーリングポリシーのターゲット追跡設定の例です。
```
{
"TargetValue": 70.0,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantInvocationsPerInstance"
},
"DisableScaleIn": true
}
```
# スケーリングポリシーを削除する
不要になったスケーリングポリシーはいつでも削除できます。
**Topics**
+ [すべてのスケーリングポリシーを削除し、モデルを登録解除する (コンソール)](#endpoint-auto-scaling-delete-console)
+ [スケーリングポリシー (AWS CLI または Application Auto Scaling API) を削除する](#endpoint-auto-scaling-delete-code)
## すべてのスケーリングポリシーを削除し、モデルを登録解除する (コンソール)
**すべてのスケーリングポリシーを削除し、バリアントをスケーラブルターゲットとして登録解除するには**
1. Amazon SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) を開きます。
1. ナビゲーションペインで、**[エンドポイント]** を選択します。
1. エンドポイントを選択し、**[エンドポイントのランタイム設定]** でバリアントを選択します。
1. [**Auto Scaling の設定**] を選択します。
1. [**Auto Scaling の登録解除**] を選択します。
## スケーリングポリシー (AWS CLI または Application Auto Scaling API) を削除する
AWS CLI または Application Auto Scaling API を使用して、バリアントからスケーリングポリシーを削除できます。
### スケーリングポリシーを削除する (AWS CLI)
スケーリングポリシーをバリアントから削除するには、[delete-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/delete-scaling-policy.html) コマンドを次のパラメータとともに使用します。
+ `--policy-name` - スケーリングポリシーの名前。
+ `--resource-id` - バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例えば、`endpoint/my-endpoint/variant/my-variant`。
+ `--service-namespace` - この値は `sagemaker` に設定します。
+ `--scalable-dimension` - この値は `sagemaker:variant:DesiredInstanceCount` に設定します。
**Example**
次の例では、`my-endpoint` エンドポイントで実行されている `my-variant` という名前のバリアントから `my-scaling-policy` という名前のターゲット追跡スケーリングポリシーを削除します。
```
aws application-autoscaling delete-scaling-policy \
--policy-name my-scaling-policy \
--resource-id endpoint/my-endpoint/variant/my-variant \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredInstanceCount
```
### スケーリングポリシーを削除する (Application Auto Scaling API)
スケーリングポリシーをバリアントから削除するには、Application Auto Scaling API アクション [DeleteScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeleteScalingPolicy.html) を次のパラメータとともに使用します。
+ `PolicyName` - スケーリングポリシーの名前。
+ `ServiceNamespace` - この値は `sagemaker` に設定します。
+ `ResourceID` - バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例えば、`endpoint/my-endpoint/variant/my-variant`。
+ `ScalableDimension` - この値は `sagemaker:variant:DesiredInstanceCount` に設定します。
**Example**
次の例では、`my-endpoint` エンドポイントで実行されている `my-variant` という名前のバリアントから `my-scaling-policy` という名前のターゲット追跡スケーリングポリシーを削除します。
```
POST / HTTP/1.1
Host: application-autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20230506T182145Z
User-Agent: aws-cli/2.0.0 Python/3.7.5 Windows/10 botocore/2.0.0dev4
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "my-scaling-policy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount"
}
```
# スケーリングアクティビティを記述してスケーリングアクティビティのステータスを確認する
スケーリングアクティビティを記述することで、自動スケーリングされたエンドポイントのスケーリングアクティビティのステータスを確認できます。Application Auto Scaling は、指定された名前空間における過去 6 週間のスケーリングアクティビティに関する詳細情報を提供します。詳細については、「*Application Auto Scaling ユーザーガイド*」の「[Scaling activities for Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scaling-activities.html)」を参照してください。
スケーリングアクティビティのステータスを確認するには、[describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html) コマンドを使用します。コンソールを使用してスケーリングアクティビティのステータスを確認することはできません。
**Topics**
+ [スケーリングアクティビティを記述する (AWS CLI)](#endpoint-how-to)
+ [ブロックされたスケーリングアクティビティをインスタンスクォータから識別する (AWS CLI)](#endpoint-identify-blocked-autoscaling)
## スケーリングアクティビティを記述する (AWS CLI)
Application Auto Scaling に登録されたすべての SageMaker AI リソースのスケーリングアクティビティを記述するには、`--service-namespace` オプションに `sagemaker` を指定して [describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html) コマンドを使用します。
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker
```
特定のリソースのスケーリングアクティビティを記述するには、`--resource-id` オプションを含めます。
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
次の例は、このコマンドを実行したときに生成される出力を示しています。
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "string",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "string",
"StatusMessage": "string"
}
```
## ブロックされたスケーリングアクティビティをインスタンスクォータから識別する (AWS CLI)
スケールアウト (インスタンスを追加) したときに、アカウントレベルのインスタンスクォータに達してしまうことがあります。[describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html) コマンドを使用して、インスタンスクォータに達したかどうかを確認できます。クォータを超過すると、自動スケーリングがブロックされます。
インスタンスクォータに達したかどうかを確認するには、[describe-scaling-activities](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/describe-scaling-activities.html) コマンドを使用し、`--resource-id` オプションでリソース ID を指定します。
```
aws application-autoscaling describe-scaling-activities \
--service-namespace sagemaker \
--resource-id endpoint/my-endpoint/variant/my-variant
```
返される構文内の [StatusCode](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusCode) と [StatusMessage](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_ScalingActivity.html#autoscaling-Type-ScalingActivity-StatusMessage) のキーおよびそれに関連付けられている値を確認します。`StatusCode` は `Failed` を返します。`StatusMessage` 内には、アカウントレベルのサービスクォータに達したことを示すメッセージがあります。以下に示しているのは、メッセージの具体的な例です。
```
{
"ActivityId": "activity-id",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/my-endpoint/variant/my-variant",
"ScalableDimension": "sagemaker:variant:DesiredInstanceCount",
"Description": "string",
"Cause": "minimum capacity was set to 110",
"StartTime": timestamp,
"EndTime": timestamp,
"StatusCode": "Failed",
"StatusMessage": "Failed to set desired instance count to 110. Reason: The
account-level service limit 'ml.xx.xxxxxx for endpoint usage' is 1000
Instances, with current utilization of 997 Instances and a request delta
of 20 Instances. Please contact AWS support to request an increase for this
limit. (Service: AmazonSageMaker; Status Code: 400;
Error Code: ResourceLimitExceeded; Request ID: request-id)."
}
```
# エンドポイントをゼロインスタンスにスケールする
エンドポイントの自動スケーリングを設定すると、スケールインプロセスでサービス内インスタンス数をゼロに減らすことができます。これにより、エンドポイントで推論リクエストを処理することがなくなり、アクティブなインスタンスを必要としない期間にコストを削減できます。
ただし、ゼロインスタンスにスケールインした後、エンドポイントでは少なくとも 1 つのインスタンスをプロビジョニングするまで受信推論リクエストに応答できません。プロビジョニングプロセスを自動化するには、Application Auto Scaling を使用してステップスケーリングポリシーを作成します。次に、Amazon CloudWatch アラームにポリシーを割り当てます。
ステップスケーリングポリシーとアラームを設定すると、エンドポイントでは応答できない推論リクエストを受け取った直後にインスタンスを自動的にプロビジョニングします。プロビジョニングプロセスには数分かかることに注意してください。その間、エンドポイントを呼び出そうとするとエラーが発生します。
次の手順では、エンドポイントがゼロインスタンスにスケールインまたはゼロインスタンスからスケールアウトするように、エンドポイントの自動スケーリングを設定する方法について説明しています。この手順では、 AWS CLIでコマンドを使用します。
**[開始する前に]**
エンドポイントがゼロインスタンスにスケールインおよびスケールアウトできるようにするには、次の要件を満たす必要があります。
+ エンドポイントが稼働中である。
+ 1 つ以上の推論コンポーネントをホストしている。エンドポイントでは、推論コンポーネントをホストしている場合にのみ、ゼロインスタンスとの間でスケーリングできます。
SageMaker AI エンドポイントで推論コンポーネントをホストする方法については、「[リアルタイム推論用のモデルをデプロイする](realtime-endpoints-deploy-models.md)」を参照してください。
+ エンドポイント設定で、本番稼働用バリアント `ManagedInstanceScaling` オブジェクトに対して `MinInstanceCount` パラメータを `0` に設定している。
このパラメータのリファレンス情報については、「[ProductionVariantManagedInstanceScaling](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantManagedInstanceScaling.html)」を参照してください。
**エンドポイントがゼロインスタンスにスケールインできるようにするには (AWS CLI)**
エンドポイントでホストしている推論コンポーネントごとに、次の操作を行います。
1. 推論コンポーネントをスケーラブルターゲットとして登録します。登録するときは、次のコマンドで示すように、最小キャパシティを `0` に設定します。
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--resource-id inference-component/inference-component-name \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--min-capacity 0 \
--max-capacity n
```
この例では、*inference-component-name* を推論コンポーネントの名前に置き換えます。*n* を、スケールアウト時にプロビジョニングする推論コンポーネントコピーの最大数に置き換えます。
このコマンドとその各パラメータの詳細については、*AWS CLI コマンドリファレンス*の「[register-scalable-target](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/register-scalable-target.html)」を参照してください。
1. 次のコマンドで示しているように、ターゲット追跡ポリシーを推論コンポーネントに適用します。
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type TargetTrackingScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--target-tracking-scaling-policy-configuration file://config.json
```
この例では、*inference-component-name* を推論コンポーネントの名前に置き換えます。
この例では、`config.json` ファイルに次のようなターゲット追跡ポリシー設定が含まれています。
```
{
"PredefinedMetricSpecification": {
"PredefinedMetricType": "SageMakerInferenceComponentInvocationsPerCopy"
},
"TargetValue": 1,
"ScaleInCooldown": 300,
"ScaleOutCooldown": 300
}
```
追跡ポリシー設定のその他の例については、「[スケーリングポリシーを定義する](endpoint-auto-scaling-add-code-define.md)」を参照してください。
このコマンドとその各パラメータの詳細については、*AWS CLI コマンドリファレンス*の「[put-scaling-policy](https://docs.aws.amazon.com/cli/latest/reference/application-autoscaling/put-scaling-policy.html)」を参照してください。
**エンドポイントがゼロインスタンスからスケールアウトできるようにするには (AWS CLI）**
エンドポイントでホストしている推論コンポーネントごとに、次の操作を行います。
1. 次のコマンドで示しているように、推論コンポーネントにステップスケーリングポリシーを適用します。
```
aws application-autoscaling put-scaling-policy \
--policy-name my-scaling-policy \
--policy-type StepScaling \
--resource-id inference-component/inference-component-name \
--service-namespace sagemaker \
--scalable-dimension sagemaker:inference-component:DesiredCopyCount \
--step-scaling-policy-configuration file://config.json
```
この例では、*my-scaling-policy* をポリシーの一意の名前に置き換えます。*inference-component-name* を推論コンポーネントの名前に置き換えます。
この例では、`config.json` ファイルには次のようなステップスケーリングポリシー設定が含まれています。
```
{
"AdjustmentType": "ChangeInCapacity",
"MetricAggregationType": "Maximum",
"Cooldown": 60,
"StepAdjustments":
[
{
"MetricIntervalLowerBound": 0,
"ScalingAdjustment": 1
}
]
}
```
このステップスケーリングポリシーがトリガーされると、SageMaker AI では推論コンポーネントのコピーをサポートするために必要なインスタンスをプロビジョニングします。
ステップスケーリングポリシーを作成したら、その Amazon リソースネーム (ARN) を書き留めます。次のステップでは、CloudWatch アラームの ARN が必要です。
ステップスケーリングポリシーの詳細については、*アプリケーション Auto Scaling ユーザーガイド*の「[ステップスケーリングポリシー](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-step-scaling-policies.html)」を参照してください。
1. 次の例に示すように、CloudWatch アラームを作成し、ステップスケーリングポリシーを割り当てます。
```
aws cloudwatch put-metric-alarm \
--alarm-actions step-scaling-policy-arn \
--alarm-description "Alarm when SM IC endpoint invoked that has 0 instances." \
--alarm-name ic-step-scaling-alarm \
--comparison-operator GreaterThanThreshold \
--datapoints-to-alarm 1 \
--dimensions "Name=InferenceComponentName,Value=inference-component-name" \
--evaluation-periods 1 \
--metric-name NoCapacityInvocationFailures \
--namespace AWS/SageMaker \
--period 60 \
--statistic Sum \
--threshold 1
```
この例では、*step-scaling-policy-arn* をステップスケーリングポリシーの ARN に置き換えます。*ic-step-scaling-alarm* を任意の名前に置き換えます。*inference-component-name* を推論コンポーネントの名前に置き換えます。
この例では `--metric-name` パラメータを `NoCapacityInvocationFailures` に設定しています。SageMaker AI では、エンドポイントが推論リクエストを受信したときにこのメトリクスを出力しますが、エンドポイントにはリクエストを処理するアクティブなインスタンスがありません。そのイベントが発生すると、アラームは前のステップのステップスケーリングポリシーを開始します。
このコマンドとその各パラメータの詳細については、*AWS CLI コマンドリファレンス*の「[put-metric-alarm](https://docs.aws.amazon.com/cli/latest/reference/cloudwatch/put-metric-alarm.html)」を参照してください。
# 自動スケーリング設定の負荷テスト
負荷テストを実行して、意図した通りに動作するスケーリング設定を選択します。
次の負荷テスト用のガイドラインでは、事前定義されたターゲットメトリクス `SageMakerVariantInvocationsPerInstance` を使用するスケーリングポリシーの使用を想定しています。
**Topics**
+ [パフォーマンス特性を明確にする](#endpoint-scaling-loadtest-variant)
+ [ターゲットの負荷を計算する](#endpoint-scaling-loadtest-calc)
## パフォーマンス特性を明確にする
負荷テストを実行し、モデルの本番稼働用バリアントが処理できる `InvocationsPerInstance` のピーク、および同時実行数の増加に伴うリクエストのレイテンシーを探し出します。
この値は選択したインスタンスタイプ、モデルのクライアントが通常送信するペイロード、モデルのすべての外部依存関係のパフォーマンスに依存します。
**モデルの本番稼働用バリアントが処理できる 1 秒あたりのピークのリクエスト数 (RPS) とリクエストのレイテンシーを探し出すには**
1. 単一のインスタンスを使用してモデルにエンドポイントを設定します。エンドポイントの設定方法の詳細については、「[SageMaker AI ホスティングサービスにモデルをデプロイする](ex1-model-deployment.md#ex1-deploy-model)」を参照してください。
1. 負荷テストツールを使用して増加する並列リクエストを生成し、負荷テストツールの出力で RPS とモデルのレイテンシーを監視します。
**注記**
また、RPS の代わりに 1 分あたりのリクエスト数を監視することもできます。その場合、式に 60 を乗算して以下に示す `SageMakerVariantInvocationsPerInstance` を計算しないでください。
モデルのレイテンシーが増加、または成功したトランザクションの割合が減少するタイミングが、バリアントが処理できるピークの RPS になります。
## ターゲットの負荷を計算する
バリアントのパフォーマンス特性を探し出した後は、インスタンスへの送信を許可する最大 RPS を決定できます。スケーリングに使用されるしきい値はこの最大値より小さくする必要があります。次の式を負荷テストと組み合わせて使用することで、スケーリング設定の `SageMakerVariantInvocationsPerInstance` ターゲットメトリクスの正しい値を決定できます。
```
SageMakerVariantInvocationsPerInstance = (MAX_RPS * SAFETY_FACTOR) * 60
```
ここで、`MAX_RPS` は以前に決定した最大 RPS で、`SAFETY_FACTOR` はクライアントが最大 RPS を超過しないように選択する安全係数です。SageMaker AI が自動スケーリングの実装に使用する 1 分あたりの CloudWatch メトリクスに合わせて、60 を乗算して RPS から 1 分あたりの呼び出し数に変換します (1 秒あたりのリクエスト数ではなく、1 分あたりのリクエスト数を計測した場合、これを行う必要はありません)。
**注記**
SageMaker AI では、`SAFETY_FACTOR` を 0.5 に設定してテストを始めることをお勧めします。スケーリング設定をテストし、エンドポイント上のお客様のトラフィックの増減がモデルで期待したとおりに動作することを確認します。
# CloudFormation を使用してスケーリングポリシーを作成する
次の例は、 CloudFormationを使用してエンドポイントのモデルの自動スケーリングを設定する方法を示しています。
```
Endpoint:
Type: "AWS::SageMaker::Endpoint"
Properties:
EndpointName: yourEndpointName
EndpointConfigName: yourEndpointConfigName
ScalingTarget:
Type: "AWS::ApplicationAutoScaling::ScalableTarget"
Properties:
MaxCapacity: 10
MinCapacity: 2
ResourceId: endpoint/my-endpoint/variant/my-variant
RoleARN: arn
ScalableDimension: sagemaker:variant:DesiredInstanceCount
ServiceNamespace: sagemaker
ScalingPolicy:
Type: "AWS::ApplicationAutoScaling::ScalingPolicy"
Properties:
PolicyName: my-scaling-policy
PolicyType: TargetTrackingScaling
ScalingTargetId:
Ref: ScalingTarget
TargetTrackingScalingPolicyConfiguration:
TargetValue: 70.0
ScaleInCooldown: 600
ScaleOutCooldown: 30
PredefinedMetricSpecification:
PredefinedMetricType: SageMakerVariantInvocationsPerInstance
```
詳細については、「*Application Auto Scaling ユーザーガイド*」の「[Configure Application Auto Scaling resources using AWS CloudFormation](https://docs.aws.amazon.com/autoscaling/application/userguide/creating-resources-with-cloudformation.html)」を参照してください。
# 自動スケーリングを使用するエンドポイントを更新する
エンドポイントを更新すると、そのエンドポイント上のモデルが自動スケーリングの対象となっているかどうかを Application Auto Scaling がチェックします。更新により自動スケーリングの対象となっているいずれかのモデルのインスタンスタイプが変更される場合、更新は失敗します。
で AWS マネジメントコンソール、モデルを更新する前にモデルを自動スケーリングから登録解除する必要があるという警告が表示されます。[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API を呼び出してエンドポイントの更新を試行すると、呼び出しが失敗します。エンドポイントを更新する前に、そのエンドポイントに設定されているスケーリングポリシーをすべて削除し、Application Auto Scaling API アクション [DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html) を呼び出してそのバリアントのスケーラブルなターゲットの登録を解除します。エンドポイントを更新した後に、更新されたバリアントをスケーラブルなターゲットとして登録し、スケーリングポリシーをアタッチできます。
1 つ例外があります。自動スケーリングの対象に設定されたバリアントのモデルを変更した場合、Amazon SageMaker AI の自動スケーリングで更新が許可されます。これは、一般的にはモデルを変更しても、スケーリング動作を変更するほどパフォーマンスには影響を及ぼさないからです。自動スケーリングの対象として設定されているバリアントのモデルを更新した場合、そのモデルへの変更がパフォーマンスとスケーリング動作に大幅に影響しないことを確認する必要があります。
自動スケーリングが適用されている SageMaker AI エンドポイントを更新するには、以下の手順を実行します。
**自動スケーリングが適用されたエンドポイントを更新するには**
1. エンドポイントをスケーラブルなターゲットとして登録解除するには、「[DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html)」を呼び出します。
1. 自動スケーリングは、更新オペレーションの進行中 (または前のステップで自動スケーリングをオフにした場合) はブロックされるため、更新中にエンドポイントのインスタンス数を増やすという追加の予防措置を講じることができます。そのためには、[UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) を呼び出して、エンドポイントでホストされている本番稼働用バリアントのインスタンスの数を更新します。
1. レスポンスの `EndpointStatus` フィールドの値が `InService` になるまで、[DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) を繰り返し呼び出します。
1. [DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) を呼び出して、現在のエンドポイント設定の値を取得します。
1. [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) を呼び出して、新しいエンドポイント設定を作成します。既存のインスタンス数または重みを保持する本番稼働用バリアントの場合、前のステップで [DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) を呼び出したときのレスポンスと同じバリアント名を使用します。他のすべての値については、前のステップで [DescribeEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpointConfig.html) を呼び出したときにレスポンスとして取得した値を使用します。
1. [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) を呼び出してエンドポイントを更新します。前のステップで作成したエンドポイント設定を `EndpointConfig` フィールドとして指定します。インスタンス数や重みなどのバリアントプロパティを保持する場合、`RetainAllVariantProperties` パラメータの値を `True` に設定します。これにより、同じ名前の本番稼働用バリアントが、新しい `EndpointConfig` の `InitialInstanceCount` フィールドの値に関係なく、`DescribeEndpoint` の呼び出しの応答から取られた最新の `DesiredInstanceCount` で更新されるように指定されます。
1. (オプション) [RegisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_RegisterScalableTarget.html) と [PutScalingPolicy](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_PutScalingPolicy.html) を呼び出して自動スケーリングを再度アクティブ化します。
**注記**
ステップ 1 と 7 は、次の変更でエンドポイントを更新する場合のみ必要です。
自動スケーリングが設定されている本番稼働用バリアントのインスタンスタイプを変更する
自動スケーリングが設定されている本番稼働用バリアントを削除する。
# 自動スケーリングに設定されたエンドポイントを削除する
エンドポイントを削除すると、そのエンドポイント上のモデルが自動スケーリングの対象となっているかどうかを Application Auto Scaling がチェックします。モデルの登録を解除するアクセス許可がある場合、Application Auto Scaling はそれらのモデルのスケーラブルなターゲットとしての登録を通知なしに解除します。[DeregisterScalableTarget](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_DeregisterScalableTarget.html) アクションのアクセス許可を付与しないカスタムアクセス許可ポリシーを使用している場合は、エンドポイントを削除する前に、このアクションへのアクセスをリクエストする必要があります。
**注記**
あるユーザーがエンドポイント上のバリアントに対して自動スケーリングを設定した場合、別の IAM ユーザーにはそのエンドポイントを削除する十分なアクセス許可がない場合があります。
# インスタンスストレージボリューム
エンドポイントが作成されると、Amazon SageMaker AI はそのエンドポイントをホストする Amazon EC2 インスタンスに Amazon Elastic Block Store (Amazon EBS) ストレージボリュームをアタッチします。ストレージボリュームのサイズはスケーラブルです。また、ストレージオプションは SSD バックドストレージと HDD バックドストレージの 2 つのカテゴリに分かれます。
Amazon EBS のストレージと機能の詳細については、以下のページを参照してください。
+ [Amazon EBS の機能](https://aws.amazon.com/ebs/features/)
+ [Amazon EBS ユーザーガイド](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html)
ホストインスタンスストレージボリュームの完全なリストについては、「[ホストインスタンスストレージボリュームの表](https://aws.amazon.com/releasenotes/host-instance-storage-volumes-table/)」を参照してください。
**注記**
Amazon SageMaker AI は、[非同期推論](async-inference.md) または [リアルタイム推論](realtime-endpoints.md) エンドポイントタイプを作成する場合にのみ、Amazon EC2 インスタンスに Amazon Elastic Block Store (Amazon EBS) ストレージボリュームをアタッチします。Amazon EBS ストレージボリュームのカスタマイズの詳細については、「[大規模モデル推論用の SageMaker AI エンドポイントパラメータ](large-model-inference-hosting.md)」を参照してください。
# 本番環境でのモデルの検証
SageMaker AI では、バリアントを使用して、同じエンドポイントの背後にある複数のモデルまたはモデルバージョンをテストできます。バリアントは、ML インスタンスと SageMaker AI モデルで指定された提供コンポーネントで構成されます。エンドポイントの背後にある複数のバリアントを使用できます。各バリアントは、異なるインスタンスタイプまたは他とは独立して自動スケーリングできる SageMaker AI モデルを使用できます。バリアント内のモデルは、異なるデータセット、異なるアルゴリズム、異なる ML フレームワーク、またはこれらすべての組み合わせを使用してトレーニングすることができます。エンドポイントの背後にあるすべてのバリアントは、同じ推論コードを共有します。SageMaker AI は、本番稼働用バリアントとシャドウバリアントの 2 種類のバリアントをサポートしています。
エンドポイントの背後に複数の本番稼働用バリアントがある場合は、推論リクエストの一部を各バリアントに割り当てることができます。各リクエストは、本番稼働用バリアントの 1 つだけにルーティングされます。リクエストがルーティングされた本番稼働バリアントが呼び出し元に応答を提供します。本番稼働用バリアントのパフォーマンスを相互に比較できます。
また、エンドポイントの背後にある本番稼働用バリアントに対応するシャドウバリアントも使用できます。本番稼働用バリアントに送信される推論リクエストの一部は、シャドウバリアントに複製されます。シャドウバリアントの応答は比較のために記録され、呼び出し元には返されません。これにより、シャドウバリアントによって生成された応答に呼び出し元を公開することなく、シャドウバリアントのパフォーマンスをテストできます。
**Topics**
+ [本番稼働用バリアントを使用してモデルをテストする](model-ab-testing.md)
+ [シャドウバリアントを使用してモデルをテストする](model-shadow-deployment.md)
# 本番稼働用バリアントを使用してモデルをテストする
本番稼働用 ML ワークフローでは、データサイエンティストやエンジニアが、[SageMaker AI の自動モデルチューニング](automatic-model-tuning.md)、追加されたデータや最新のデータのトレーニング、機能選択の改善、より適切に更新されたインスタンスの使用、コンテナの提供など、さまざまな方法を使用して頻繁にパフォーマンスの改善を試みています。本番稼働用バリアントを使用して、モデル、インスタンス、コンテナを比較し、推論リクエストに応答するのに最もパフォーマンスの高い候補を選択できます。
SageMaker AI マルチバリアントエンドポイントでは、各バリアントにトラフィック分散を提供することで、エンドポイント呼び出し要求を複数の本番環境用バリアントに分散できます。または、リクエストごとに特定のバリアントを直接呼び出すこともできます。このトピックでは、ML モデルをテストするための両方の方法について説明します。
**Topics**
+ [トラフィック分散を指定してモデルをテストする](#model-testing-traffic-distribution)
+ [特定のバリアントを呼び出してモデルをテストする](#model-testing-target-variant)
+ [モデル A/B テスト例](#model-ab-test-example)
## トラフィック分散を指定してモデルをテストする
複数のモデル間でトラフィックを分散してテストするには、エンドポイント構成の各本番稼働用バリアントの重みを指定して、各モデルにルーティングされるトラフィックの割合を指定します。詳細については、「[CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)」をご覧ください。次の図は、この詳しい仕組みを示しています。
![\[SageMaker AI で InvokeEndpoint を使用してモデル間でトラフィックを分散する仕組みを示す例。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-traffic-distribution.png)
## 特定のバリアントを呼び出してモデルをテストする
リクエストごとに特定のモデルを呼び出して複数のモデルをテストするには、[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) を呼び出すときに、`TargetVariant` パラメータの値を入力して呼び出す特定のモデルバージョンを指定します。SageMaker AI は指定した本番稼働用バリアントを使用してリクエストが処理されるようにします。すでにトラフィック分散を指定し、 `TargetVariant` パラメータに値を指定している場合、ターゲットルーティングによってランダムなトラフィック分散が上書きされます。次の図は、この詳しい仕組みを示しています。
![\[SageMaker AI で InvokeEndpoint を使用してリクエストごとに特定のモデルを呼び出す仕組みを示す例。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-target-variant.png)
## モデル A/B テスト例
新しいモデルと本番稼働用トラフィックのある古いモデル間で A/B テストを実行することは、新しいモデルの検証プロセスの効果的な最終ステップとなります。A/B テストでは、モデルのさまざまなバリアントをテストし、各バリアントのパフォーマンスを比較します。モデルの新しいバージョンが、既存のバージョンよりも優れたパフォーマンスを発揮する場合は、モデルの古いバージョンを本番環境の新しいバージョンに置き換えます。
次の例は、A/B モデルのテストの実行方法を示しています。この例を実装したサンプルノートブックについては、 「[本番環境での A/B テスト ML モデル](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_endpoints/a_b_testing/a_b_testing.html)」を参照してください。
### ステップ 1: モデルの作成とデプロイ
まず、Amazon S3 のどこにモデルが配置されるかを定義します。これらの場所は、以降のステップでモデルをデプロイするときに使用されます。
```
model_url = f"s3://{path_to_model_1}"
model_url2 = f"s3://{path_to_model_2}"
```
次に、イメージとモデルデータを使用してモデルオブジェクトを作成します。これらのモデルオブジェクトは、エンドポイントに本番稼働用バリアントをデプロイするために使用されます。モデルは、異なるデータセット、異なるアルゴリズムまたは ML フレームワーク、および異なるハイパーパラメータで ML モデルをトレーニングすることによって開発されます。
```
from sagemaker.amazon.amazon_estimator import get_image_uri
model_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
model_name2 = f"DEMO-xgb-churn-pred2-{datetime.now():%Y-%m-%d-%H-%M-%S}"
image_uri = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-1')
image_uri2 = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-2')
sm_session.create_model(
name=model_name,
role=role,
container_defs={
'Image': image_uri,
'ModelDataUrl': model_url
}
)
sm_session.create_model(
name=model_name2,
role=role,
container_defs={
'Image': image_uri2,
'ModelDataUrl': model_url2
}
)
```
ここでは、それぞれ独自のモデルとリソース要件 (インスタンスタイプと数) が異なる 2 つの本番稼働用バリアントを作成します。これにより、さまざまなインスタンスタイプでモデルをテストすることもできます。
両方のバリアントの initial\$1weight を 1 に設定します。これにより、リクエストの 50% が `Variant1` に送信され、残りの 50% が `Variant2` に送信されます。両方のバリアントの重みの合計は 2 で、各バリアントの重みの割り当ては 1 です。つまり、各バリアントは合計トラフィックの 1/2 (50%) を受信することになります。
```
from sagemaker.session import production_variant
variant1 = production_variant(
model_name=model_name,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant1',
initial_weight=1,
)
variant2 = production_variant(
model_name=model_name2,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant2',
initial_weight=1,
)
```
これで、これらの本番稼働用バリアントを SageMaker AI エンドポイントにデプロイする準備が整いました。
```
endpoint_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
print(f"EndpointName={endpoint_name}")
sm_session.endpoint_from_production_variants(
name=endpoint_name,
production_variants=[variant1, variant2]
)
```
### ステップ 2: デプロイされたモデルを呼び出す
今度は、このエンドポイントにリクエストを送信して、リアルタイムで推論を取得します。トラフィック分散と直接ターゲティングの両方を使用します。
まず、前のステップで構成したトラフィック分散を使用します。各推論応答には、要求を処理する本番稼働用バリアントの名前が含まれているため、2 つの本番稼働用バリアントへのトラフィックはほぼ等しいことがわかります。
```
# get a subset of test data for a quick test
!tail -120 test_data/test-dataset-input-cols.csv > test_data/test_sample_tail_input_cols.csv
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload
)
time.sleep(0.5)
print("Done!")
```
SageMaker AI は、Amazon CloudWatch のバリアントごとに `Latency` や `Invocations` などのメトリクスを出力します。SageMaker AI が出力するメトリクスの詳しいリストについては、「[Amazon CloudWatch における Amazon SageMaker AI メトリクス](monitoring-cloudwatch.md)」を参照してください。CloudWatch をクエリしてバリアントごとの呼び出し回数を取得し、バリアント間で呼び出しを分割するデフォルトの方法を表示します。
![\[CloudWatch によるバリアントごとの呼び出し数の例。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-variant-invocations.png)
次に、`TargetVariant` の呼び出しで `Variant1` を `invoke_endpoint` としてを指定することで、モデルの特定のバージョンを呼び出します。
```
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload,
TargetVariant="Variant1"
)
time.sleep(0.5)
```
すべての新しい呼び出しが `Variant1` によって処理されたことを確認するには、CloudWatch のクエリを実行して、バリアントごとの呼び出し回数を取得します。最新の呼び出し (最新のタイムスタンプ) では、指定されたようにすべてのリクエストが `Variant1` によって処理されたことがわかります。`Variant2` に対する呼び出しはありませんでした。
![\[CloudWatch によるバリアントごとの呼び出し数の例。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-invocations-target1.png)
### ステップ 3: モデルパフォーマンスの評価
どのモデルバージョンがより優れたパフォーマンスを発揮するかを確認するために、各バリアントの曲線の下にある正確性、精度、リコール、F1 スコア、レシーバー動作特性/領域を評価します。まず、`Variant1` のメトリクスを見てみましょう。
![\[Variant1 の受信者操作特性曲線の例。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-curve.png)
次に、`Variant2` のメトリクスを見てみましょう。
![\[Variant2 の受信者操作特性曲線の例。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model2-curve.png)
定義済みのメトリクスのほとんどについて、`Variant2` のパフォーマンスが向上しているため、本番環境で使用するのはこれになります。
### ステップ 4: 最適なモデルに対するトラフィックの増加
`Variant2` のパフォーマンスが `Variant1` より優れていると判断したため、より多くのトラフィックをそちらにシフトさせます。引き続き `TargetVariant` を使用して特定のモデルバリアントを呼び出すことができますが、より簡単なアプローチは、[UpdateEndPointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) を呼び出して各バリアントに割り当てられた重みを更新する方法です。これにより、エンドポイントを更新することなく、運用バリアントへのトラフィック分散が変更されます。セットアップセクションから、トラフィックを 50/50 に分割するようバリアントの重みを設定したことを思い出してください。以下の各バリアントの合計呼び出し回数の CloudWatch メトリクスは、各バリアントの呼び出しパターンを示しています。
![\[各バリアントの合計呼び出し数の CloudWatch メトリクスの例。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-invocations-even-dist.png)
`UpdateEndpointWeightsAndCapacities` を使用して各バリアントに新しい重みを割り当てることで、トラフィックの 75% を `Variant2` に移動します。SageMaker AI は推論リクエストの 75% を`Variant2` に、残りの 25% を `Variant1` に送ります。
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 25,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 75,
"VariantName": variant2["VariantName"]
}
]
)
```
各バリアントの合計呼び出し回数の CloudWatch メトリクスは、`Variant2` の呼び出しのほうが `Variant1` よりも呼び出し回数が多いことを示しています。
![\[各バリアントの合計呼び出し数の CloudWatch メトリクスの例。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-invocations-75-25.png)
引き続きメトリクスを監視し、バリアントのパフォーマンスに満足したら、トラフィックの 100% をそのバリアントにルーティングできます。[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) を使用して、バリアントのトラフィック割り当てを更新します。`Variant1` の重みを 0 に、`Variant2` の重みを 1 に設定します。SageMaker AI はすべての推論リクエストの 100% を `Variant2` に送信します。
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 0,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 1,
"VariantName": variant2["VariantName"]
}
]
)
```
各バリアントの合計呼び出し回数の CloudWatch メトリクスは、すべての推論リクエストを `Variant2` が処理し、`Variant1` が処理する推論リクエストがないことを示しています。
![\[各バリアントの合計呼び出し数の CloudWatch メトリクスの例。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/model-invocations-best-model.png)
これで、エンドポイントを安全に更新し、エンドポイントから `Variant1` を削除できるようになりました。エンドポイントに新しいバリアントを追加し、ステップ 2 ～ 4 を実行することで、本番環境での新しいモデルのテストを続行することもできます。
# シャドウバリアントを使用してモデルをテストする
SageMaker AI Model Shadow Deployments を使用すると、長期間実行されるシャドウバリアントを作成して、モデル提供スタックの新しい候補コンポーネントを本番環境に昇格させる前に検証できます。次の図は、シャドウバリアントの詳しい仕組みを示しています。
![\[シャドウバリアントの詳細。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/juxtaposer/shadow-variant.png)
## シャドウバリアントのデプロイ
次のコード例は、シャドウバリアントをプログラムによってデプロイする方法を示しています。例の*ユーザープレースホルダーテキスト*を独自の情報に置き換えます。
1. 2 つの SageMaker AI モデルを作成します。1 つは本番稼働バリアント用、もう 1 つはシャドウバリアント用です。
```
import boto3
from sagemaker import get_execution_role, Session
aws_region = "aws-region"
boto_session = boto3.Session(region_name=aws_region)
sagemaker_client = boto_session.client("sagemaker")
role = get_execution_role()
bucket = Session(boto_session).default_bucket()
model_name1 = "name-of-your-first-model"
model_name2 = "name-of-your-second-model"
sagemaker_client.create_model(
ModelName = model_name1,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-first-model",
"ModelDataUrl": "s3-location-of-trained-first-model"
}
]
)
sagemaker_client.create_model(
ModelName = model_name2,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-second-model",
"ModelDataUrl": "s3-location-of-trained-second-model"
}
]
)
```
1. エンドポイント設定を作成します。設定で本番稼働用バリアントとシャドウバリアントの両方を指定します。
```
endpoint_config_name = name-of-your-endpoint-config
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": name-of-your-production-variant,
"ModelName": model_name1,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
],
ShadowProductionVariants=[
{
"VariantName": name-of-your-shadow-variant,
"ModelName": model_name2,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
]
)
```
1. エンドポイントを作成します。
```
create_endpoint_response = sm.create_endpoint(
EndpointName=name-of-your-endpoint,
EndpointConfigName=endpoint_config_name,
)
```
# SageMaker Clarify によるオンライン説明可能性
このガイドでは、SageMaker Clarify を使用してオンライン説明可能性を設定する方法を説明します。SageMaker AI [リアルタイム推論](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html)エンドポイントを使用すると、説明可能性をリアルタイムで継続的に分析できます。オンラインでの説明可能性機能は、[Amazon SageMaker AI 機械学習ワークフロー](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-mlconcepts.html)の**本番環境へのデプロイ**の部分に適合します。
## Clarify オンライン説明可能性の仕組み
次の図は、説明可能性リクエストを処理するエンドポイントをホストするための SageMaker AI アーキテクチャを示しています。エンドポイント、モデルコンテナ、および SageMaker Clarify 説明機能の間のインタラクションを示しています。
![\[説明可能性リクエストをオンデマンドで処理するエンドポイントのホスティングを示す SageMaker AI のアーキテクチャ。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/clarify/DeveloperGuideArchitecture.png)
Clarify オンライン説明可能性の仕組みは次のとおりです。アプリケーションは REST スタイルの `InvokeEndpoint` リクエストを SageMaker AI ランタイムサービスに送信します。サービスはこのリクエストを SageMaker AI エンドポイントにルーティングして、予測と説明を取得します。次に、サービスはエンドポイントからレスポンスを受け取ります。最後に、サービスはレスポンスをアプリケーションに送り返します。
エンドポイントの可用性を高めるため、SageMaker AI はエンドポイント設定のインスタンス数に応じて、エンドポイントインスタンスを複数のアベイラビリティーゾーンに自動的に分散しようとします。エンドポイントインスタンスでは、新しい説明可能性リクエストがあると、SageMaker Clarify の説明機能が予測のためにモデルコンテナを呼び出します。次に、特徴量の属性を計算して返します。
SageMaker Clarify のオンライン説明可能性を使用するエンドポイントを作成するための 4 つのステップは次のとおりです。
1. 事前トレーニング済みの SageMaker AI モデルがオンライン説明可能性に対応しているかどうかを、[事前チェック](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html)の手順に従って確認します。
1. `CreateEndpointConfig` API を使用して SageMaker Clarify の説明機能設定で[エンドポイント設定を作成](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)します。
1. `CreateEndpoint` API を使用して[エンドポイントを作成](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)し、SageMaker AI にエンドポイント設定を提供します。このサービスは、ML コンピューティングインスタンスを起動し、設定で指定されたモデルをデプロイします。
1. [エンドポイントを呼び出す](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html): エンドポイントが稼働状態になったら、SageMaker AI ランタイム API `InvokeEndpoint` を呼び出してエンドポイントにリクエストを送信します。その後、エンドポイントは説明と予測を返します。
# モデルコンテナの事前チェック
このセクションでは、エンドポイントを設定する前に、モデルコンテナの入力と出力の互換性を事前にチェックする方法を説明します。SageMaker Clarify の説明機能は**モデルに依存しません**が、モデルコンテナの入出力に関する要件があります。
**注記**
1 回のリクエストで 2 つ以上のレコードをサポートするバッチリクエストをサポートするようにコンテナを設定すると、効率を高めることができます。例えば、1 つのレコードは 1 行の CSV データ、または 1 行の JSON Lines データです。SageMaker Clarify は、単一レコードのリクエストにフォールバックする前に、まずミニバッチのレコードをモデルコンテナに送信しようとします。
## モデルコンテナ入力
------
#### [ CSV ]
モデルコンテナは MIME タイプの CSV (`text/csv`) での入力をサポートします。次の表は、SageMaker Clarify がサポートする入力例を示しています。
| モデルコンテナ入力 (文字列表現) | コメント |
| --- | --- |
| '1,2,3,4' | 4 つの数値特徴を使用する 1 つのレコード。 |
| '1,2,3,4\$1n5,6,7,8' | 改行 '\$1n' で区切られた 2 つのレコード。 |
| '"This is a good product",5' | テキスト特徴量と数値特徴量を含む 1 つのレコード。 |
| ‘"This is a good product",5\$1n"Bad shopping experience",1' | 2 つのレコード。 |
------
#### [ JSON Lines ]
SageMaker AI は、次の表に示すように、[MIME タイプの JSON Lines 高密度形式 (`application/jsonlines`)](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-jsonlines) での入力もサポートしています。
| モデルコンテナ入力 | コメント |
| --- | --- |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1' | 単一レコード。特徴量のリストは JMESPath 式 `data.features` で抽出できます。 |
| '\$1"data":\$1"features":[1,2,3,4]\$1\$1\$1n\$1"data":\$1"features":[5,6,7,8]\$1\$1' | 2 つのレコード。 |
| '\$1"features":["This is a good product",5]\$1' | 単一レコード。特徴量のリストは JMESPath 式 `features` で抽出できます。 |
| '\$1"features":["This is a good product",5]\$1\$1n\$1"features":["Bad shopping experience",1]\$1' | 2 つのレコード。 |
------
## モデルコンテナ出力
モデルコンテナの出力も CSV または JSON Lines 高密度形式である必要があります。さらに、モデルコンテナには、SageMaker Clarify が特徴量属性の計算に使用する入力レコードの確率を含める必要があります。
以下のデータ例は **CSV 形式**のモデルコンテナ出力用です。
------
#### [ Probability only ]
リグレッションと二項分類の問題では、モデルコンテナは予測ラベルの単一の確率値 (スコア) を出力します。これらの確率は、列インデックス 0 を使用して抽出できます。マルチクラス問題の場合、モデルコンテナは確率 (スコア) のリストを出力します。マルチクラス問題では、インデックスが提供されない場合、すべての値が抽出されます。
| モデルコンテナ入力 | モデルコンテナ出力 (文字列表現) |
| --- | --- |
| 1 つのレコード | '0.6' |
| 2 つのレコード (結果は 1 行) | '0.6,0.3' |
| 2 つのレコード (結果は 2 行) | '0.6\$1n0.3' |
| マルチクラスモデル の 1 つのレコード (3 つのクラス) | '0.1,0.6,0.3' |
| マルチクラスモデルの 2 つのレコード (3 つのクラス) | '0.1,0.6,0.3\$1n0.2,0.5,0.3' |
------
#### [ Predicted label and probabilities ]
モデルコンテナは、予測ラベルの後にその確率を **CSV 形式**で出力します。確率はインデックス `1` を使用して抽出できます。
| モデルコンテナ入力 | モデルコンテナ出力 |
| --- | --- |
| シングルレコード | '1,0.6' |
| 2 つのレコード | '1,0.6\$1n0,0.3' |
------
#### [ Predicted labels header and probabilities ]
Autopilot でトレーニングされたマルチクラスモデルコンテナは、予測ラベルと確率のリストの**文字列表現**を **CSV** 形式で出力するように設定できます。次の例では、確率をインデックス `1` で抽出できます。ラベルヘッダーはインデックス `1` で抽出でき、ラベルヘッダーはインデックス `0` を使用して抽出できます。
| モデルコンテナ入力 | モデルコンテナ出力 |
| --- | --- |
| 単一レコード | '"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.1,0.6,0.3]"' |
| 2 つのレコード | '"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.1,0.6,0.3]"\$1n"[\$1'cat\$1',\$1'dog\$1',\$1'fish\$1']","[0.2,0.5,0.3]"' |
------
以下は、**JSON Lines** 形式のモデルコンテナ出力のデータ例です。
------
#### [ Probability only ]
この例では、モデルコンテナは [https://jmespath.org/](https://jmespath.org/) 式 `score` で抽出できる確率を **JSON Lines** 形式で出力しています。
| モデルコンテナ入力 | モデルコンテナ出力 |
| --- | --- |
| シングルレコード | '\$1"score":0.6\$1' |
| 2 つのレコード | '\$1"score":0.6\$1\$1n\$1"score":0.3\$1' |
------
#### [ Predicted label and probabilities ]
この例では、マルチクラスモデルコンテナは、ラベルヘッダーのリストと確率のリストを **JSON Lines** 形式で出力します。確率は `JMESPath` 式 `probability` で抽出でき、ラベルヘッダーは `JMESPath` 式 `predicted labels` で抽出できます。
| モデルコンテナ入力 | モデルコンテナ出力 |
| --- | --- |
| 単一レコード | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| 2 つのレコード | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]\$1' |
------
#### [ Predicted labels header and probabilities ]
この例では、マルチクラスモデルコンテナは、ラベルヘッダーと確率のリストを **JSON Lines** 形式で出力します。確率は `JMESPath` 式 `probability` で抽出でき、ラベルヘッダーは `JMESPath` 式 `predicted labels` で抽出できます。
| モデルコンテナ入力 | モデルコンテナ出力 |
| --- | --- |
| 単一レコード | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1' |
| 2 つのレコード | '\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]\$1\$1n\$1"predicted\$1labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]\$1' |
------
## モデルコンテナの検証
モデルを SageMaker AI リアルタイム推論エンドポイントにデプロイし、エンドポイントにリクエストを送信することをお勧めします。リクエスト (モデルコンテナ入力) とレスポンス (モデルコンテナ出力) を手動で確認し、両方が**モデルコンテナ入力**セクションと**モデルコンテナ出力**セクションの要件に準拠していることを確認します。モデルコンテナがバッチリクエストをサポートしている場合は、1 つのレコードリクエストから始めて、2 つ以上のレコードを試してみることができます。
次のコマンドは、 AWS CLIを使用してレス本スをリクエストする方法を示します。 AWS CLI は SageMaker Studio Classic インスタンスと SageMaker ノートブックインスタンスにプリインストールされています。をインストールする必要がある場合は AWS CLI、この[インストールガイド](https://aws.amazon.com/cli/)に従ってください。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name $ENDPOINT_NAME \
--content-type $CONTENT_TYPE \
--accept $ACCEPT_TYPE \
--body $REQUEST_DATA \
$CLI_BINARY_FORMAT \
/dev/stderr 1>/dev/null
```
パラメータの定義は次のとおりです。
+ `$ENDPOINT NAME`: エンドポイントの名前。
+ `$CONTENT_TYPE`: リクエストの MIME タイプ (モデルコンテナ入力)。
+ `$ACCEPT_TYPE`: レスポンスの MIME タイプ (モデルコンテナ出力)。
+ `$REQUEST_DATA`: リクエストされたペイロード文字列。
+ `$CLI_BINARY_FORMAT`: コマンドラインインターフェイス (CLI) パラメータの形式。v1 AWS CLI の場合、このパラメータは空白のままにする必要があります。v2 では、このパラメータは `--cli-binary-format raw-in-base64-out` に設定する必要があります。
**注記**
AWS CLI v2 は、base64 でエンコードされた文字列の[デフォルト](https://docs.aws.amazon.com/cli/latest/userguide/cliv2-migration.html#cliv2-migration-binaryparam)としてバイナリパラメータを渡します。
次の例では v1 AWS CLI を使用しています。
------
#### [ Request and response in CSV format ]
+ リクエストは 1 つのレコードで構成され、レスポンスはその確率値です。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
出力:
`0.6`
+ リクエストは 2 つのレコードで構成され、レスポンスにはそれぞれの確率が含まれ、モデルは確率をカンマで区切ります。`--body` 内の `$'content'` 式は、コンテンツの `\n` を改行として解釈するようにコマンドに指示します。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-sagemaker-xgboost-model \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
出力:
`0.6,0.3`
+ リクエストは 2 つのレコードで構成され、レスポンスにはそれぞれの確率が含まれ、モデルは確率を改行で区切ります。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
出力:
`0.6`
`0.3`
+ リクエストは 1 つのレコードで構成され、レスポンスは確率値 (マルチクラスモデル、3 クラス) です。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body '1,2,3,4' \
/dev/stderr 1>/dev/null
```
出力:
`0.1,0.6,0.3`
+ リクエストは 2 つのレコードで構成され、レスポンスにはそれぞれの確率値 (マルチクラスモデル、3 クラス) が含まれます。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-1 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
出力:
`0.1,0.6,0.3`
`0.2,0.5,0.3`
+ リクエストは 2 つのレコードで構成され、レスポンスには予測ラベルと確率が含まれます。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-2 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
出力:
`1,0.6`
`0,0.3`
+ リクエストは 2 つのレコードで構成され、レスポンスにはラベルヘッダーと確率が含まれます。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-3 \
--content-type text/csv \
--accept text/csv \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
出力:
`"['cat','dog','fish']","[0.1,0.6,0.3]"`
`"['cat','dog','fish']","[0.2,0.5,0.3]"`
------
#### [ Request and response in JSON Lines format ]
+ リクエストは 1 つのレコードで構成され、レスポンスはその確率値です。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines \
--content-type application/jsonlines \
--accept application/jsonlines \
--body '{"features":["This is a good product",5]}' \
/dev/stderr 1>/dev/null
```
出力:
`{"score":0.6}`
+ リクエストには 2 つのレコードが含まれ、レスポンスには予測ラベルと確率が含まれます。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-2 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
出力:
`{"predicted_label":1,"probability":0.6}`
`{"predicted_label":0,"probability":0.3}`
+ リクエストには 2 つのレコードが含まれ、レスポンスにはラベルヘッダーと確率が含まれます。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-3 \
--content-type application/jsonlines \
--accept application/jsonlines \
--body $'{"data":{"features":[1,2,3,4]}}\n{"data":{"features":[5,6,7,8]}}' \
/dev/stderr 1>/dev/null
```
出力:
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.1,0.6,0.3]}`
`{"predicted_labels":["cat","dog","fish"],"probabilities":[0.2,0.5,0.3]}`
------
#### [ Request and response in different formats ]
+ リクエストは CSV 形式で、レスポンスは JSON Lines 形式です。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-csv-in-jsonlines-out \
--content-type text/csv \
--accept application/jsonlines \
--body $'1,2,3,4\n5,6,7,8' \
/dev/stderr 1>/dev/null
```
出力:
`{"probability":0.6}`
`{"probability":0.3}`
+ リクエストは JSON Lines 形式で、レスポンスは CSV 形式です。
```
aws sagemaker-runtime invoke-endpoint \
--endpoint-name test-endpoint-jsonlines-in-csv-out \
--content-type application/jsonlines \
--accept text/csv \
--body $'{"features":[1,2,3,4]}\n{"features":[5,6,7,8]}' \
/dev/stderr 1>/dev/null
```
出力:
`0.6`
`0.3`
------
検証が完了したら、テストエンドポイントを[削除](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-delete-resources.html)します。
# エンドポイントの設定と作成
モデルに合わせて新しいエンドポイント設定を作成し、この設定を使用してエンドポイントを作成します。[事前チェックステップ](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-online-explainability-precheck.html)で検証されたモデルコンテナを使用してエンドポイントを作成し、SageMaker Clarify オンライン説明可能性機能を有効にすることができます。
`sagemaker_client` オブジェクトを使用し、[CreateEndpointConfig](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_CreateEndpointConfig.html) API を使用してエンドポイントを作成します。`ExplainerConfig` パラメータ内のメンバー `ClarifyExplainerConfig` を次のように設定します。
```
sagemaker_client.create_endpoint_config(
EndpointConfigName='name-of-your-endpoint-config',
ExplainerConfig={
'ClarifyExplainerConfig': {
'EnableExplanations': '`true`',
'InferenceConfig': {
...
},
'ShapConfig': {
...
}
},
},
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': 'name-of-your-model',
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}]
...
)
sagemaker_client.create_endpoint(
EndpointName='name-of-your-endpoint',
EndpointConfigName='name-of-your-endpoint-config'
)
```
`sagemaker_client` オブジェクトへの最初の呼び出しにより、説明可能性機能が有効になった新しいエンドポイント設定が作成されます。2 回目の呼び出しでは、エンドポイント設定を使用してエンドポイントを起動します。
**注記**
また、[SageMaker AI リアルタイム推論マルチモデルエンドポイント](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html)の背後にある 1 つのコンテナに複数のモデルをホストし、SageMaker Clarify を使用してオンライン説明可能性を設定することもできます。
# `EnableExplanations` 式
`EnableExplanations` パラメータは [https://jmespath.org/](https://jmespath.org/) ブール式の文字列です。説明可能性リクエストの**各レコード**について評価されます。このパラメータが **true** と評価されると、レコードが説明されます。このパラメータが **false** と評価された場合、説明は生成されません。
SageMaker Clarify は、各レコードのモデルコンテナ出力を JSON 互換のデータ構造に逆シリアル化し、`EnableExplanations` パラメータを使用してデータを評価します。
**注意事項**
モデルコンテナ出力の形式に応じて、レコードには 2 つのオプションがあります。
モデルコンテナの出力が CSV 形式の場合、レコードは JSON 配列としてロードされます。
モデルコンテナの出力が JSON Lines 形式の場合、レコードは JSON オブジェクトとしてロードされます。
`EnableExplanations` パラメータは JMESPath 式で、`InvokeEndpoint` または `CreateEndpointConfig` 操作中に渡すことができます。指定した JMESPath 式が有効でない場合、エンドポイントの作成は失敗します。式は有効でも、式の評価結果が予想外のものであれば、エンドポイントは正常に作成されますが、エンドポイントが呼び出されるとエラーが生成されます。`InvokeEndpoint` API を使用して `EnableExplanations` 式をテストし、エンドポイント設定に適用します。
有効な `EnableExplanations` 式の例を次に示します。この例では、JMESPath 式はバックティック文字を使用してリテラルを囲んでいます。例えば、``true`` は true を意味します。
| エクスプレッション (文字列表現) | モデルコンテナ出力 (文字列表現) | 評価結果 (ブール値) | 意味 |
| --- | --- | --- | --- |
| '`true`' | (N/A) | 正 | オンライン説明可能性を無条件に有効にします。 |
| '`false`' | (N/A) | 誤 | オンライン説明可能性を無条件に無効にします。 |
| '[1]>`0.5`' | '1,0.6' | 正 | モデルコンテナは、レコードごとに予測ラベルと確率を出力します。確率 (インデックス 1) が 0.5 より大きいレコードを説明します。 |
| 'probability>`0.5`' | '\$1"predicted\$1label":1,"probability":0.6\$1' | 正 | モデルコンテナはレコードごとに JSON データを出力します。確率が 0.5 より大きい場合、そのレコードを説明します。 |
| '\$1contains(probabilities[:-1], max(probabilities))' | '\$1"probabilities": [0.4, 0.1, 0.4], "labels":["cat","dog","fish"]\$1' | 誤 | マルチクラスモデルの場合: 予測ラベル (最大確率値を持つクラス) が最後のクラスであれば、レコードを説明します。文字どおり、この式は、最後のものを除いて、最大確率値が確率のリストに含まれていないことを意味します。 |
# 合成データセット
SageMaker Clarify はカーネル SHAP アルゴリズムを使用しています。レコード (サンプルまたはインスタンスとも呼ばれる) と SHAP 設定が与えられると、説明機能はまず合成データセットを生成します。次に、SageMaker Clarify はモデルコンテナにデータセットの予測を問い合わせてから、特徴量属性を計算して返します。合成データセットのサイズは、Clarify の説明機能のランタイムに影響します。合成データセットが大きいほど、小さい合成データセットよりもモデル予測の取得に時間がかかります。
合成データセットのサイズは次の式で決定されます。
```
Synthetic dataset size = SHAP baseline size * n_samples
```
SHAP ベースラインサイズは SHAP ベースラインデータ内のレコード数です。この情報は `ShapBaselineConfig` から取得されます。
`n_samples` のサイズは、説明機能設定内の `NumberOfSamples` パラメータと特徴量の数によって設定されます。特徴量の数が `n_features` の場合、`n_samples` は次のようになります。
```
n_samples = MIN(NumberOfSamples, 2^n_features - 2)
```
`NumberOfSamples` が指定されない場合の `n_samples` は以下のようになります。
```
n_samples = MIN(2*n_features + 2^11, 2^n_features - 2)
```
例えば、10 個の特徴量を含む表形式レコードの SHAP ベースラインサイズは 1 です。`NumberOfSamples` が指定されない場合、合成データセットには 1022 のレコードが含まれます。レコードに 20 の特徴量がある場合、合成データセットには 2088 のレコードが含まれます。
NLP 問題の場合、`n_features` はテキスト以外の特徴量の数にテキスト単位の数を加えたものに等しくなります。
**注記**
`InvokeEndpoint` API にはリクエストのタイムアウト制限があります。合成データセットが大きすぎる場合、説明機能はこの制限内で計算を完了できない可能性があります。必要に応じて、前述の情報を利用して SHAP のベースラインサイズと `NumberOfSamples` を把握して減らします。モデルコンテナがバッチリクエストを処理するように設定されている場合は、`MaxRecordCount` の値を調整することもできます。
# エンドポイントの呼び出し
エンドポイントが実行されたら、SageMaker AI ランタイムサービスの SageMaker AI ランタイム [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) API を使用して、エンドポイントにリクエストを送信したり、エンドポイントを呼び出したりします。それに応じて、リクエストは SageMaker Clarify 説明機能によって説明可能性リクエストとして処理されます。
**注記**
エンドポイントを呼び出すには、次のオプションのいずれかを選択します。
Boto3 または を使用してエンドポイントを AWS CLI 呼び出す手順については、「」を参照してください[リアルタイム推論用のモデルを呼び出す](realtime-endpoints-test-endpoints.md)。
SageMaker SDK for Python を使用してエンドポイントを呼び出すには、「[予想子](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html) API」を参照してください。
## リクエスト
`InvokeEndpoint` API にはオプションパラメータ `X-Amzn-SageMaker-Enable-Explanations` があり、HTTP ヘッダー `EnableExplanations` にマッピングされています。このパラメータを指定すると、`ClarifyExplainerConfig` の `EnableExplanations` のパラメータが上書きされます。
**注記**
`InvokeEndpoint` API の `ContentType` パラメータと `Accept` パラメータは必須です。サポートされている形式には、MIME タイプ `text/csv` と `application/jsonlines` があります。
`sagemaker_runtime_client` を使用して、次のようにエンドポイントにリクエストを送信します。
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName='name-of-your-endpoint',
EnableExplanations='`true`',
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4', # single record (of four numerical features)
)
```
マルチモデルエンドポイントの場合は、前のリクエスト例で追加の `TargetModel` パラメータを渡して、エンドポイントでどのモデルをターゲットにするかを指定します。マルチモデルエンドポイントは、必要に応じてターゲットモデルを動的にロードします。マルチモデルエンドポイントの詳細については、「[マルチモデルエンドポイント](multi-model-endpoints.md)」を参照してください。単一のエンドポイントから複数のターゲットモデルを設定して呼び出す方法の例については、「[マルチモデルエンドポイントの SageMaker Clarify オンライン説明可能性サンプルノートブック](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular_multi_model_endpoint/multi_model_xgboost_with_online_explainability.ipynb)」を参照してください。
## 応答
エンドポイントが `ExplainerConfig` で作成された場合、新しいレスポンススキーマが使用されます。この新しいスキーマは、指定された `ExplainerConfig` パラメータがないエンドポイントとは異なり、互換性がありません。
レスポンスの MIME タイプは `application/json` で、レスポンスペイロードは UTF-8 バイトから JSON オブジェクトにデコードできます。この JSON オブジェクトのメンバーを次に示します。
+ `version`: 文字列形式のレスポンススキーマのバージョン。例えば、`1.0`。
+ `predictions`: リクエストが行う予測は以下のとおりです。
+ `content_type`: モデルコンテナレスポンスの `ContentType` を参照した、予測の MIME タイプ。
+ `data`: リクエストに対するモデルコンテナレスポンスのペイロードとして配信される予測データ文字列。
+ `label_headers`: `LabelHeaders` パラメータのラベルヘッダー。これは説明機能の設定またはモデルコンテナ出力で提供されます。
+ `explanations`: リクエストペイロードで提供される説明。レコードが説明されていない場合、このメンバーは空のオブジェクト `{}` を返します。
+
+ `kernel_shap`: リクエスト内にある各レコードのカーネル SHAP 説明の配列を参照するキー。レコードが説明されていない場合、対応する説明は `null` です。
`kernel_shap` 要素には以下のメンバーがあります。
+ `feature_header`: 説明機能設定 `ExplainerConfig` の `FeatureHeaders` パラメータで提供される特徴量のヘッダー名。
+ `feature_type`: 説明機能が推測した、または `ExplainerConfig` の `FeatureTypes` パラメータで提供された特徴量タイプ。この要素は NLP の説明可能性問題でのみ使用できます。
+ `attributions`: 属性オブジェクトの配列。テキスト特徴量には、それぞれ 1 つの単位に対応する複数の属性オブジェクトを含めることができます。属性オブジェクトには以下のメンバーがあります。
+ `attribution`: クラスごとに指定された確率値のリスト。
+ `description`: NLP の説明可能性問題にのみ使用できるテキスト単位の説明。
+ `partial_text`: 説明機能が説明したテキストの部分。
+ `start_idx`: 部分的テキストフラグメントの先頭の配列位置を識別するゼロベースのインデックス。
# コード例: SDK for Python
このセクションでは、SageMaker Clarify オンライン説明可能性を使用するエンドポイントを作成および呼び出すためのサンプルコードを提供します。これらのコード例では [AWS SDK for Python](https://aws.amazon.com/sdk-for-python/) を使用しています。
## 表形式のデータ
次の例では、表形式のデータと、`model_name` という名前の SageMaker AI モデルを使用しています。この例では、モデルコンテナは CSV 形式のデータを受け入れ、各レコードには 4 つの数値特徴量があります。この最小限の設定では、**デモンストレーションのみを目的として**、SHAP ベースラインデータは 0 に設定されています。`ShapBaseline` により適切な値を選択する方法については、「[説明可能性のための SHAP ベースライン](clarify-feature-attribute-shap-baselines.md)」を参照してください。
エンドポイントを次のように設定します。
```
endpoint_config_name = 'tabular_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '0,0,0,0',
},
},
},
},
)
```
エンドポイント設定を使用して、次のようにエンドポイントを作成します。
```
endpoint_name = 'tabular_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
`DescribeEndpoint` API を使用して、次のようにエンドポイント作成の進行状況を確認します。
```
response = sagemaker_client.describe_endpoint(
EndpointName=endpoint_name,
)
response['EndpointStatus']
```
エンドポイントのステータスが「InService」になったら、次のようにテストレコードを使用してエンドポイントを呼び出します。
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
)
```
**注記**
前述のコード例では、マルチモデルエンドポイントの場合、リクエストに追加の `TargetModel` パラメータを渡して、エンドポイントでターゲットとするモデルを指定します。
レスポンスのステータスコードが 200 (エラーなし) であると仮定し、次のようにレスポンスの本文をロードします。
```
import codecs
import json
json.load(codecs.getreader('utf-8')(response['Body']))
```
エンドポイントのデフォルトのアクションは、レコードの説明です。以下は、返される JSON オブジェクトの出力例です。
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.0006380207487381"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [-0.00433456]
}
]
},
{
"attributions": [
{
"attribution": [-0.005369821]
}
]
},
{
"attributions": [
{
"attribution": [0.007917749]
}
]
},
{
"attributions": [
{
"attribution": [-0.00261214]
}
]
}
]
]
}
}
```
`EnableExplanations` パラメータを使用して、以下のようにオンデマンドの説明を有効にします。
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='1,2,3,4',
EnableExplanations='[0]>`0.8`',
)
```
**注記**
前述のコード例では、マルチモデルエンドポイントの場合、リクエストに追加の `TargetModel` パラメータを渡して、エンドポイントでターゲットとするモデルを指定します。
この例では、予測値がしきい値 `0.8` を下回っているため、レコードは説明されません。
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv; charset=utf-8",
"data": "0.6380207487381995"
},
"explanations": {}
}
```
視覚化ツールを使用すると、返される説明を解釈するのに役立ちます。以下の図は、各特徴が予測にどのように寄与するかを理解するために SHAP プロットを使用する方法を示しています。この図上のベース値は、予想値とも呼ばれ、トレーニングデータセットの平均予測値です。予想値を高くする特徴は赤、予想値を下げる特徴は青です。追加情報については、「[SHAP アディティブフォースレイアウト](https://shap.readthedocs.io/en/latest/generated/shap.plots.force.html)」を参照してください。
![\[SHAP プロットの例。各特徴量が予測にどのように貢献するかを把握するために使用できます。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/clarify/force-plot.png)
「[表形式データの完全なサンプルノートブック](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/tabular/tabular_online_explainability_with_sagemaker_clarify.ipynb)」を参照してください。
## テキストデータ
このセクションでは、テキストデータのオンライン説明可能性エンドポイントを作成して呼び出すコード例を紹介します。コード例では SDK for Python を使用しています。
次の例では、テキストデータと `model_name` という SageMaker AI モデルを使用しています。この例では、モデルコンテナは CSV 形式のデータを受け入れ、各レコードは 1 つの文字列です。
```
endpoint_config_name = 'text_explainer_endpoint_config'
response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[{
'VariantName': 'AllTraffic',
'ModelName': model_name,
'InitialInstanceCount': 1,
'InstanceType': 'ml.m5.xlarge',
}],
ExplainerConfig={
'ClarifyExplainerConfig': {
'InferenceConfig': {
'FeatureTypes': ['text'],
'MaxRecordCount': 100,
},
'ShapConfig': {
'ShapBaselineConfig': {
'ShapBaseline': '""',
},
'TextConfig': {
'Granularity': 'token',
'Language': 'en',
},
'NumberOfSamples': 100,
},
},
},
)
```
+ `ShapBaseline`: 自然言語処理 (NLP) 処理用に予約された特別なトークンです。
+ `FeatureTypes`: 特徴量をテキストとして識別します。このパラメータが指定されていない場合、説明機能は特徴量タイプを推測しようとします。
+ `TextConfig`: テキストの特徴量を分析するための粒度と言語の単位を指定します。この例では、言語は英語で、粒度 `token` は英語テキストの単語を指します。
+ `NumberOfSamples`: 合成データセットのサイズの上限を設定する制限。
+ `MaxRecordCount`: モデルコンテナが処理できるリクエスト内の最大レコード数。このパラメータはパフォーマンスを安定させるために設定されています。
エンドポイント設定を使用して、次のようにエンドポイントを作成します。
```
endpoint_name = 'text_explainer_endpoint'
response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name,
)
```
エンドポイントのステータスが `InService` になったら、エンドポイントを呼び出します。次のコードサンプルでは、テストレコードを次のように使用しています。
```
response = sagemaker_runtime_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType='text/csv',
Accept='text/csv',
Body='"This is a good product"',
)
```
リクエストが正常に完了すると、レスポンスの本文は次のような有効な JSON オブジェクトを返します。
```
{
"version": "1.0",
"predictions": {
"content_type": "text/csv",
"data": "0.9766594\n"
},
"explanations": {
"kernel_shap": [
[
{
"attributions": [
{
"attribution": [
-0.007270948666666712
],
"description": {
"partial_text": "This",
"start_idx": 0
}
},
{
"attribution": [
-0.018199033666666628
],
"description": {
"partial_text": "is",
"start_idx": 5
}
},
{
"attribution": [
0.01970993241666666
],
"description": {
"partial_text": "a",
"start_idx": 8
}
},
{
"attribution": [
0.1253469515833334
],
"description": {
"partial_text": "good",
"start_idx": 10
}
},
{
"attribution": [
0.03291143366666657
],
"description": {
"partial_text": "product",
"start_idx": 15
}
}
],
"feature_type": "text"
}
]
]
}
}
```
視覚化ツールを使用すると、返されるテキスト属性を解釈するのに役立ちます。次の画像は、各単語が予測にどれほど寄与しているかを理解するために、captum 可視化ユーティリティを使用する方法を示しています。彩度が高いほど、その単語の重要度も高くなります。この例では、彩度の高い明るい赤色は、マイナスの影響が強いことを示しています。彩度の高い緑色はプラスの影響が強いことを示しています。白色はその単語の寄与が中立であることを示します。属性の解析とレンダリングに関する追加情報については、「[captum](https://github.com/pytorch/captum)」ライブラリを参照してください。
![\[各単語が予測にどれだけ寄与しているかを理解するために使用される Captum 可視化ユーティリティ。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/clarify/word-importance.png)
「[テキストデータの完全なノートブックのサンプル](https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-clarify/online_explainability/natural_language_processing/nlp_online_explainability_with_sagemaker_clarify.ipynb)」を参照してください。
# トラブルシューティングガイド
SageMaker Clarify オンライン説明機能の使用時にエラーが発生した場合は、このセクションのトピックを参照してください。
**`InvokeEndpoint` API が「ReadTimeoutError: エンドポイントの読み取りタイムアウト...」というエラーで失敗する**
このエラーは、[リクエストタイムアウト](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html)によって設定された 60 秒の制限時間内にリクエストを完了できなかったことを意味します。
リクエストのレイテンシーを短縮するには、以下を試してください。
+ 推論中のモデルのパフォーマンスを調整します。たとえば、SageMaker AI [Neo](https://aws.amazon.com/sagemaker/neo/) は推論用にモデルを最適化できます。
+ モデルコンテナがバッチリクエストを処理できるようにします。
+ より大きな `MaxRecordCount` を使用して、説明機能からモデルコンテナへの呼び出し回数を減らします。これにより、ネットワークレイテンシーとオーバーヘッドが低減されます。
+ より多くのリソースが割り当てられているインスタンスタイプを使用します。または、より多くのインスタンスをエンドポイントに割り当てて、負荷を分散します。
+ 1 つの `InvokeEndpoint` リクエストに含まれるレコード数を減らします。
+ ベースラインデータのレコード数を減らします。
+ より小さい `NumberOfSamples` 値を使用して、合成データセットのサイズを小さくします。サンプル数が合成データセットにどのように影響するかについては、「[合成データセット](clarify-online-explainability-create-endpoint-synthetic.md)」を参照してください。
# アダプター推論コンポーネントを使用してモデルをファインチューニングする
Amazon SageMaker AI では、独自のモデルをゼロから作成することなく、事前トレーニング済みの基盤モデルをホストできます。ただし、自社のビジネスに固有のニーズに合わせて汎用基盤モデルを調整するには、そのファインチューニングされたバージョンを作成する必要があります。コスト効率の高いファインチューニング手法の 1 つが Low-Rank Adaptation (LoRA) です。大規模な基盤モデルのごく一部しか、新しいタスクやドメインに合わせて更新する必要がないという原則が LoRA にはあります。LoRA アダプターでは、わずか数個の追加のアダプターレイヤーでベース基盤モデルからの推論を強化します。
SageMaker AI 推論コンポーネントを使用してベース基盤モデルをホストする場合、*アダプター推論コンポーネント*を作成することで、そのベースモデルを LoRA アダプターでファインチューニングできます。アダプター推論コンポーネントを作成するときは以下を指定します。
+ アダプター推論コンポーネントを含めることになる*ベース推論コンポーネント*。ベース推論コンポーネントには調整する基盤モデルが含まれています。アダプター推論コンポーネントでは、ベース推論コンポーネントに割り当てたコンピューティングリソースを使用します。
+ LoRA アダプターを Amazon S3 に保存した場所。
作成したアダプター推論コンポーネントは直接呼び出すことができます。これを行うと、SageMaker AI によってアダプターがベースモデルと組み合わされ、生成された応答が強化されます。
**[開始する前に]**
アダプター推論コンポーネントを作成する前に、次の要件を満たす必要があります。
+ 調整する基盤モデルを含むベース推論コンポーネントが用意されている。この推論コンポーネントを SageMaker AI エンドポイントにデプロイした。
推論コンポーネントをエンドポイントにデプロイする方法の詳細については、「[リアルタイム推論用のモデルをデプロイする](realtime-endpoints-deploy-models.md)」を参照してください。
+ LoRA アダプターモデルがあり、モデルアーティファクトが `tar.gz` ファイルとして Amazon S3 に保存されている。アダプター推論コンポーネントを作成するときに、アーティファクトの S3 URI を指定します。
次の例では、SDK for Python (Boto3) を使用してアダプター推論コンポーネントの作成と呼び出しを行っています。
**Example アダプター推論コンポーネントを作成するための `create_inference_component` 呼び出し**
次の例では、アダプター推論コンポーネントを作成し、ベース推論コンポーネントにそれを割り当てています。
```
sm_client.create_inference_component(
InferenceComponentName = adapter_ic_name,
EndpointName = endpoint_name,
Specification={
"BaseInferenceComponentName": base_inference_component_name,
"Container": {
"ArtifactUrl": adapter_s3_uri
},
},
)
```
この例を自身のコードで使用する場合は、次のようにプレースホルダー値を置き換えてください。
+ *adapter\$1ic\$1name* – アダプター推論コンポーネントの一意の名前。
+ *endpoint\$1name* – ベース推論コンポーネントをホストするエンドポイントの名前。
+ *base\$1inference\$1component\$1name* – 調整する基盤モデルを含むベース推論コンポーネントの名前。
+ *adapter\$1s3\$1uri* – LoRA アダプターアーティファクトを含む `tar.gz` ファイルを特定する S3 URI。
通常の推論コンポーネントのコードに似たコードでアダプター推論コンポーネントを作成します。`Specification` パラメータで `ComputeResourceRequirements` キーを省略する点が通常の推論コンポーネントのコードとは異なる点です。アダプター推論コンポーネントを呼び出すと、ベース推論コンポーネントによってロードされます。アダプター推論コンポーネントでは、ベース推論コンポーネントのコンピューティングリソースを使用します。
SDK for Python (Boto3) を使用した推論コンポーネントの作成とデプロイの詳細については、「[Python SDK でモデルをデプロイする](realtime-endpoints-deploy-models.md#deploy-models-python)」を参照してください。
アダプター推論コンポーネントを作成したら、`invoke_endpoint` リクエストでその名前を指定してそのコンポーネントを呼び出します。
**Example アダプター推論コンポーネントを呼び出すための `invoke_endpoint` 呼び出し**
次の例ではアダプター推論コンポーネントを呼び出しています。
```
response = sm_rt_client.invoke_endpoint(
EndpointName = endpoint_name,
InferenceComponentName = adapter_ic_name,
Body = json.dumps(
{
"inputs": prompt,
"parameters": {"max_new_tokens": 100, "temperature":0.9}
}
),
ContentType = "application/json",
)
adapter_reponse = response["Body"].read().decode("utf8")["generated_text"]
```
この例を自身のコードで使用する場合は、次のようにプレースホルダー値を置き換えてください。
+ *endpoint\$1name* – ベース推論コンポーネントとアダプター推論コンポーネントをホストするエンドポイントの名前。
+ *adapter\$1ic\$1name* – アダプター推論コンポーネントの名前。
+ *prompt* – 推論リクエストのプロンプト。
SDK for Python (Boto3) を使用した推論コンポーネントの呼び出しの詳細については、「[リアルタイム推論用のモデルを呼び出す](realtime-endpoints-test-endpoints.md)」を参照してください。
# Amazon SageMaker Serverless Inference を使用してモデルをデプロイする
Amazon SageMaker Serverless Inference は、基盤となるインフラストラクチャを設定または管理せずに、ML モデルをデプロイおよびスケールする専用の推論オプションです。オンデマンドのサーバーレス推論は、トラフィックの増加の間にアイドル期間があり、コールドスタートを許容できるワークロードに最適です。サーバーレスエンドポイントは、コンピューティングリソースを自動的に起動し、トラフィックに応じてスケールインおよびスケールアウトできるため、インスタンスタイプを選択したり、スケーリングポリシーを管理したりする必要がなくなります。これにより、サーバーを選択し管理する画一的な負荷の大きい作業から解放されます。サーバーレス推論は AWS Lambda と統合され、高可用性、組み込みの耐障害性、オートスケーリングを提供します。従量課金モデルでは、頻度の低いまたは予測不可能なトラフィックパターンがある場合、サーバーレス推論は費用対効果の高いオプションです。リクエストがない間、サーバーレス推論はエンドポイントを 0 にスケールダウンし、コストを最小限に抑えます。オンデマンドサーバーレス推論の料金の詳細については、「[Amazon SageMaker の料金](https://aws.amazon.com/sagemaker/pricing/)」を参照してください。
オプションで、サーバーレス推論でプロビジョニングされた同時実行を利用することもできます。プロビジョニングされた同時実行を使用したサーバーレス推論は、トラフィックの急増が予測できる場合に費用対効果の高いオプションです。プロビジョニングされた同時実行を使用すると、エンドポイントをウォーム状態に保つことで、予測可能なパフォーマンスと高いスケーラビリティを備えたサーバーレスエンドポイントにモデルをデプロイできます。SageMaker AI では、割り当てたプロビジョニングされた同時実行の分だけ、コンピュートリソースが初期化され、ミリ秒以内に応答できるようになっています。プロビジョニングされた同時実行を使用したサーバーレス推論では、推論リクエストの処理に使用されたコンピューティング性能 (ミリ秒単位で課金)、および処理されたデータ量に対して料金を支払います。また、設定されているメモリ、プロビジョニングされた期間、および有効になっている同時実行数に基づいて、プロビジョニングされた同時実行の使用量に対しても料金が発生します。プロビジョニングされた同時実行を使用したサーバーレス推論の料金の詳細については、「[Amazon SageMaker の料金](https://aws.amazon.com/sagemaker/pricing/)」を参照してください。
サーバーレス推論を MLOps パイプラインと統合して ML ワークフローを効率化できます。また、サーバーレスエンドポイントを使用して[モデルレジストリ](model-registry.md)に登録されたモデルをホストできます。
サーバーレス推論は、米国東部 (バージニア北部）、米国東部 (オハイオ）、米国西部 (北カリフォルニア）、米国西部 (オレゴン）、アフリカ (ケープタウン）、アジアパシフィック (香港）、アジアパシフィック (ムンバイ）、アジアパシフィック (東京）、アジアパシフィック (ソウル）、アジアパシフィック (大阪）、アジアパシフィック (シンガポール）、アジアパシフィック (シドニー）、カナダ (中部）、欧州 (フランクフルト）、欧州 (アイルランド）、欧州 (ロンドン）、欧州 (パリ）、欧州 (ストックホルム）、欧州 (ミラノ）、中東 (バーレーン）、南米 (サンパウロ) の 21 AWS リージョンで一般利用可能です。Amazon SageMaker AI を利用できるリージョンについては、[リージョン別に利用可能なAWS サービスのリスト](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/)を参照してください。
## 仕組み
次の図表は、オンデマンドのサーバーレス推論のワークフローと、サーバーレスエンドポイントを使用する利点を示しています。
![\[サーバーレス推論ワークフローを示す図。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/serverless-endpoints-how-it-works.png)
オンデマンドのサーバーレスエンドポイントを作成すると、SageMaker AI はコンピューティングリソースをプロビジョニングおよび管理します。次に、エンドポイントに推論リクエストを行い、レスポンスでモデル予測を受け取ることができます。SageMaker AI は、リクエストトラフィックを処理するために必要に応じてコンピューティングリソースをスケールアップおよびスケールダウンし、使用した分だけ料金が発生します。
プロビジョニングされた同時実行については、サーバーレス推論はアプリケーションの自動スケーリングとも統合されるため、ターゲットメトリクスまたはスケジュールに基づいてプロビジョニングされた同時実行を管理できます。詳細については、「[サーバーレスエンドポイントのプロビジョニングされた同時実行の自動スケール](serverless-endpoints-autoscale.md)」を参照してください。
次のセクションでは、サーバーレス推論とその仕組みに関する追加の詳細について説明します。
**Topics**
+ [コンテナのサポート](#serverless-endpoints-how-it-works-containers)
+ [メモリサイズ](#serverless-endpoints-how-it-works-memory)
+ [同時呼び出し](#serverless-endpoints-how-it-works-concurrency)
+ [コールドスタートの最小化](#serverless-endpoints-how-it-works-cold-starts)
+ [機能の除外](#serverless-endpoints-how-it-works-exclusions)
### コンテナのサポート
エンドポイントコンテナの場合、SageMaker AI が提供するコンテナを選択するか、独自のコンテナを持ち込むことができます。SageMaker AI は、Apache MXNet、TensorFlow、PyTorch、Chainer など、いくつかの最も一般的な機械学習フレームワーク用に、組み込みアルゴリズムおよび構築済みの Docker イメージのコンテナを提供しています。利用可能な SageMaker イメージのリストについては、「[使用可能なDeep Learning Containers イメージ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md)」を参照してください。独自のコンテナを持ち込む場合は、SageMaker AI で動作するようにコンテナを変更する必要があります。独自のコンテナの持ち込みの詳細については、「[Amazon SageMaker AI 用に独自の推論コンテナを適応させる](adapt-inference-container.md)」を参照してください。
使用できるコンテナイメージの最大サイズは 10 GB です。サーバーレスエンドポイントの場合、コンテナ内にワーカーを 1 つだけ作成し、モデルのコピーを 1 つだけロードすることをお勧めします。これは、一部の SageMaker AI コンテナが推論リクエストを処理して各ワーカーにモデルをロードするために vCPU ごとにワーカーを作成するリアルタイムエンドポイントとは異なります。
リアルタイムエンドポイント用のコンテナが既にある場合は、サーバーレスエンドポイントに同じコンテナを使用できますが、一部の機能は除外されます。サーバーレス推論でサポートされていないコンテナ機能の詳細については、「[機能の除外](#serverless-endpoints-how-it-works-exclusions)」を参照してください。同じコンテナを使用することを選択した場合、SageMaker AI は、イメージを使用するすべてのエンドポイントを削除するまで、コンテナイメージのコピーをエスクロー (保持) します。SageMaker AI は、コピーした保管中のイメージを SageMaker AI 所有の AWS KMS キーで暗号化します。
### メモリサイズ
サーバーレスエンドポイントの最小 RAM サイズは 1024 MB (1 GB) で、選択できる最大 RAM サイズは 6144 MB (6 GB) です。選択できるメモリサイズは、1024 MB、2048 MB、3072 MB、4096 MB、5120 MB、6144 MBです。サーバーレス推論は、選択したメモリに比例してコンピューティングリソースを自動的に割り当てます。より大きなメモリサイズを選択すると、コンテナはより多くの vCPUs にアクセスできます。モデルサイズに応じて、エンドポイントのメモリサイズを選択します。一般に、メモリサイズは少なくともモデルサイズと同じ大きさである必要があります。レイテンシー SLA に基づいてモデルに適したメモリを選択するために、ベンチマークが必要になる場合があります。ベンチマークのステップバイステップガイドについては、「[Introducing the Amazon SageMaker Serverless Inference Benchmarking Toolkit](https://aws.amazon.com/blogs/machine-learning/introducing-the-amazon-sagemaker-serverless-inference-benchmarking-toolkit/)」を参照してください。メモリサイズの増分には、異なる料金体系があります。詳細は、[Amazon SageMaker AI の料金ページ](https://aws.amazon.com/sagemaker/pricing/)を参照してください。
選択したメモリサイズに関係なく、サーバーレスエンドポイントには 5 GB の利用可能なエフェメラルディスクストレージがあります。ストレージを操作するときのコンテナ許可の問題については、「[トラブルシューティング](serverless-endpoints-troubleshooting.md)」を参照してください。
### 同時呼び出し
オンデマンドサーバーレス推論は、エンドポイントの容量に関する事前定義されたスケーリングポリシーとクォータを管理します。サーバーレスエンドポイントには、同時に処理できる同時呼び出しの数に対するクォータがあります。最初のリクエストの処理が完了する前にエンドポイントが呼び出されると、2 番目のリクエストを同時に処理します。
アカウント内のすべてのサーバーレスエンドポイント間で共有できる同時実行数の合計は、次のようにリージョンによって異なります。
+ アカウントにおけるリージョンごとにすべてのサーバーレスエンドポイント間で共有できる同時実行数の合計が 1000 になるリージョン: 米国東部 (オハイオ)、米国東部 (バージニア北部)、米国西部 (オレゴン)、アジアパシフィック (シンガポール)、アジアパシフィック (シドニー)、アジアパシフィック (東京)、欧州 (フランクフルト)、欧州 (アイルランド)
+ アカウントにおけるリージョンごとの合計同時実行数が 500 になるリージョン: 米国西部 (北カリフォルニア)、アフリカ (ケープタウン)、アジアパシフィック (香港)、アジアパシフィック (ムンバイ)、アジアパシフィック (大阪)、アジアパシフィック (ソウル)、カナダ (中部)、欧州 (ロンドン)、欧州 (ミラノ)、欧州 (パリ)、欧州 (ストックホルム)、中東 (バーレーン)、南米 (サンパウロ)
1 つのエンドポイントの最大同時実行数は最大 200 に設定でき、リージョンでホストできるサーバーレスエンドポイントの合計数は 50 です。個々のエンドポイントの最大同時実行数は、そのエンドポイントがアカウントで許可されているすべての呼び出しを取得することを防ぎ、最大値を超えるエンドポイント呼び出しをスロットリングします。
**注記**
サーバーレスエンドポイントに割り当てるプロビジョニングされた同時実行数は、常にそのエンドポイントに割り当てた最大同時実行数以下でなければなりません。
エンドポイントの最大同時実行数を設定する方法については、「[エンドポイント設定を作成する](serverless-endpoints-create-config.md)」を参照してください。クォータと制限の詳細については、*AWS 全般のリファレンス* の「[Amazon SageMaker AI endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html)」を参照してください。サービスの制限の引き上げをリクエストするには、「[AWS サポート](https://console.aws.amazon.com/support)」までお問い合わせください。サービス制限の引き上げリクエストについては、「[サポートされているリージョンおよびクォータ](regions-quotas.md)」を参照してください。
### コールドスタートの最小化
オンデマンドサーバーレス推論エンドポイントがしばらくトラフィックを受信せず、エンドポイントが突然新しいリクエストを受信した場合、エンドポイントがコンピューティングリソースをスピンアップしてリクエストを処理するまでに時間がかかることがあります。これは、*コールドスタート*と呼ばれます。サーバーレスエンドポイントはオンデマンドでコンピューティングリソースをプロビジョニングするため、エンドポイントでコールドスタートが発生する可能性があります。コールドスタートは、同時リクエストが現在の同時リクエストの使用量を超えた場合にも発生する可能性があります。コールドスタート時間は、モデルのサイズ、モデルのダウンロードにかかる時間、コンテナの起動時間によって異なります。
コールドスタート時間の長さをモニタリングするには、Amazon CloudWatch メトリクス `OverheadLatency` を使用して、サーバーレスエンドポイントをモニタリングします。このメトリクスは、エンドポイントの新しいコンピューティングリソースの起動にかかる時間を追跡します。サーバーレスエンドポイントでの CloudWatch メトリクスの使用方法の詳細については、「[サーバーレスエンドポイントからメトリクスを追跡するためのアラームとログ](serverless-endpoints-monitoring.md)」を参照してください。
プロビジョニングされた同時実行を使用することにより、コールドスタートを最小限に抑えることができます。SageMaker AI は、割り当てられたプロビジョニングされた同時実行数の分だけエンドポイントをウォーム状態に保ち、ミリ秒単位で応答できるようにします。
### 機能の除外
SageMaker AI リアルタイム推論で現在利用可能な機能の一部は、GPUs、 AWS 市場モデルパッケージ、プライベート Docker レジストリ、マルチモデルエンドポイント、VPC 設定、ネットワーク分離、データキャプチャ、複数の本番稼働用バリアント、Model Monitor、推論パイプラインなど、サーバーレス推論ではサポートされていません。
インスタンスベースのリアルタイムエンドポイントをサーバーレスエンドポイントに変換することはできません。リアルタイムエンドポイントをサーバーレスに更新しようとすると、`ValidationError`メッセージが表示されます。サーバーレスエンドポイントをリアルタイムに変換することはできますが、更新を行うと、サーバーレスにロールバックできません。
## 開始方法
SageMaker AI コンソール、 AWS SDKs、[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference)、および を使用して、サーバーレスエンドポイントを作成、更新、説明、削除できます AWS CLI。 AWS SDKs、[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference)、および を使用してエンドポイントを呼び出すことができます AWS CLI。プロビジョニングされた同時実行を使用したサーバーレスエンドポイントの場合、アプリケーションの自動スケーリングを使用して、ターゲットメトリクスまたはスケジュールに基づいてプロビジョニングされた同時実行数を自動スケーリングできます。サーバーレスエンドポイントの設定および使用方法の詳細については、「[サーバーレスエンドポイントの操作](serverless-endpoints-create-invoke-update-delete.md)」のガイドをお読みください。プロビジョニングされた同時実行を使用したサーバーレスエンドポイントの自動スケーリングの詳細については、「[サーバーレスエンドポイントのプロビジョニングされた同時実行の自動スケール](serverless-endpoints-autoscale.md)」を参照してください。
**注記**
プロビジョニングされた同時実行を使用したサーバーレス推論のアプリーエションの自動スケーリングは、現在 AWS CloudFormationではサポートされていません。
### ノートブックとブログの例
エンドツーエンドのサーバーレスエンドポイントワークフローを示す Jupyter Notebook の例については、「[Serverless Inference example notebooks](https://github.com/aws/amazon-sagemaker-examples/tree/master/serverless-inference)」を参照してください。
# サーバーレスエンドポイントの操作
他の SageMaker AI リアルタイムエンドポイントとは異なり、サーバーレス推論はコンピューティングリソースを管理し、複雑さを軽減するので、ユーザーはインフラストラクチャの管理ではなく ML モデルに集中できるようになります。次のガイドでは、エンドポイントの作成、呼び出し、更新、説明、または削除の方法といった、サーバーレスエンドポイントの主な機能について説明します。SageMaker AI コンソール、 AWS SDKs、[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-serverless-inference)、または を使用して AWS CLI 、サーバーレスエンドポイントを管理できます。
**Topics**
+ [の前提条件を満たす](serverless-endpoints-prerequisites.md)
+ [サーバーレスエンドポイントの作成](serverless-endpoints-create.md)
+ [サーバーレスエンドポイントを呼び出す](serverless-endpoints-invoke.md)
+ [サーバーレスエンドポイントを更新する](serverless-endpoints-update.md)
+ [サーバーレスエンドポイントを記述する](serverless-endpoints-describe.md)
+ [サーバーレスエンドポイントを削除する](serverless-endpoints-delete.md)
# の前提条件を満たす
このトピックでは、サーバーレスエンドポイントを作成する前に満たす必要がある前提条件について説明します。これらの前提条件には、モデルアーティファクトの適切な保存、正しいアクセス許可を持つ AWS IAM の設定、コンテナイメージの選択が含まれます。
**前提条件を完了する方法**
1. ** AWS アカウントをセットアップします。**まず、 AWS アカウントと AWS Identity and Access Management 管理者ユーザーが必要です。 AWS アカウントを設定する方法については、[「新しい AWS アカウントを作成してアクティブ化する方法](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/)」を参照してください。アカウントを IAM 管理者ユーザーで保護する方法の手順については、*IAM ユーザーガイド*の「[最初の IAM ユーザーおよび管理者グループの作成](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html)」を参照してください。
1. **Amazon S3 バケットを作成する。**Amazon S3 バケットを使用して、モデルのアーティファクトを保存します。バケットの作成方法については、Amazon S3 ユーザーガイドの「[最初の S3 バケットを作成する](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html)」を参照してください。**
1. **モデルのアーティファクトを S3 バケットにアップロードします。**モデルをバケットにアップロードする方法については、Amazon S3 ユーザーガイドの「[バケットにオブジェクトをアップロードする](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html)」を参照してください。**
1. **Amazon SageMaker AI 用の IAM ロールを作成する。**Amazon SageMaker AI は、モデルを保存する S3 バケットにアクセスする必要があります。SageMaker AI にバケットへの読み取りアクセス権を付与するポリシーを使用して IAM ロールを作成します。次の手順では、コンソールでロールを作成する方法を示していますが、*IAM ユーザーガイド*の [CreateRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_CreateRole.html) API を使用することもできます。ユースケースに基づいてロールに詳細な権限を付与する方法については、「[SageMaker AI 実行ロールの使用方法](sagemaker-roles.md#sagemaker-roles-createmodel-perms)」を参照してください。
1. [IAM コンソール](https://console.aws.amazon.com/iam/)にサインインします。
1. [ナビゲーション] タブで、**[Roles]** (ロール) を選択します。
1. **[ロールの作成]** を選択します。
1. **[信頼するエンティティタイプを選択]** で、**[AWS サービス]**、**[SageMaker AI]** の順に選択します。
1. **[Next: Permissions]** (次へ: 許可)、**[Next: Tags]** (次へ: タグ) の順に選択します。
1. (オプション) ロールのメタデータが必要な場合は、キーバリューペアとしてタグを追加します。
1. **[Next: Review]** (次へ: レビュー) を選択します。
1. **ロール名**に、 AWS アカウント内で一意の新しいロールの名前を入力します。ロールの作成後にロール名を編集することはできません。
1. (オプション) **[Role description]** に、新しいロールの説明を入力します。
1. **[ロールの作成]** を選択します。
1. **S3 バケットのアクセス許可を SageMaker AI ロールにアタッチする。**IAM ロールを作成した後、モデルアーティファクトを含む S3 バケットにアクセスする権限を SageMaker AI に付与するポリシーをアタッチします。
1. IAM コンソールのナビゲーションタブで **[Roles]** (ロール) を選択します。
1. ロールのリストから、前のステップで作成したロールを名前で検索します。
1. ロールを選択し、**[Attach policies]** (ポリシーをアタッチ) を選択します。
1. **[Attach permissions]** (アクセス許可をアタッチ) で、**[Create policy]** (ポリシーの作成) を選択します。
1. **[Create policy]** (ポリシーの作成) で、**[JSON]** タブを選択します。
1. JSON エディタに、次のポリシーステートメントを追加します。`` を、モデルアーティファクトを保存する S3 バケットの名前に置き換えます。バケット内の特定のフォルダまたはファイルへのアクセスを制限する場合は、`/` のように、Amazon S3 フォルダパスを指定することもできます。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::/*"
}
]
}
```
------
1. **[次へ: タグ]** を選択します。
1. (オプション) キーバリューペアのタグをポリシーに追加します。
1. **[次へ: レビュー]** を選択します。
1. **[Name]** (名前) に新しいポリシーの名前を入力します。
1. (オプション) ポリシーの**説明**を追加します。
1. **[Create policy]** (ポリシーの作成) を選択します。
1. ポリシーを作成したら、[IAM コンソール](https://console.aws.amazon.com/iam/)の**[ロール]** に戻り、SageMaker AI ロールを選択します。
1. **[ポリシーをアタッチ]** を選択します。
1. **[Attach permissions]** (アクセス許可をアタッチ) では、作成したポリシーを名前で検索します。それを選択し、**[Attach policy]** (ポリシーをアタッチ) を選択します。
1. **構築済みの Docker コンテナイメージを選択するか、独自のイメージを使用します。**選択したコンテナは、エンドポイントで推論を行います。SageMaker AI は、Apache MXNet、TensorFlow、PyTorch、Chainer など、いくつかの最も一般的な機械学習フレームワーク用に、組み込みアルゴリズムと事前構築された Docker イメージ用のコンテナを提供しています。使用可能な SageMaker イメージの完全なリストについては、「[使用可能な Deep Learning Containers イメージ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md)」を参照してください。
既存の SageMaker AI コンテナがニーズを満たしていない場合は、独自の Docker コンテナを作成する必要がある場合があります。Docker イメージを作成し、SageMaker AI との互換性を持たせる方法については、「[カスタム推論コードを持つコンテナ](your-algorithms-inference-main.md)」を参照してください。サーバーレスエンドポイントでコンテナを使用するには、コンテナイメージがエンドポイントを作成するのと同じ AWS アカウント内の Amazon ECR リポジトリに存在する必要があります。
1. **(オプション) モデルレジストリを使用してモデルを登録します。**[SageMaker モデルレジストリ](model-registry.md)は、ML パイプラインで使用するモデルのバージョンのカタログを作成し、管理するのに役立ちます。モデルのバージョン登録に関する詳細については、「[モデルグループを作成する](model-registry-model-group.md)」と「[モデルバージョンを登録する](model-registry-version.md)」を参照してください。モデルレジストリとサーバーレス推論のワークフローの例については、次の[サンプルノートブック](https://github.com/aws/amazon-sagemaker-examples/blob/main/serverless-inference/serverless-model-registry.ipynb)を参照してください。
1. **(オプション) AWS KMS キーを持ち込みます。**サーバーレスエンドポイントを設定する場合、SageMaker AI が Amazon ECR イメージの暗号化に使用する KMS キーを指定するというオプションがあります。KMS キーのキーポリシーが、エンドポイントの設定時に指定する IAM ロールへのアクセスを許可している必要があることにご注意ください。KMS キーの詳細については、「[AWS Key Management Service デベロッパーガイド](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)」を参照してください。
# サーバーレスエンドポイントの作成
**重要**
Amazon SageMaker Studio または Amazon SageMaker Studio Classic に Amazon SageMaker リソースの作成を許可するカスタム IAM ポリシーでは、これらのリソースにタグを追加するアクセス許可も付与する必要があります。Studio と Studio Classic は、作成したリソースに自動的にタグ付けするため、リソースにタグを追加するアクセス許可が必要になります。IAM ポリシーで Studio と Studio Classic によるリソースの作成が許可されていても、タグ付けが許可されていない場合は、リソースを作成しようとしたときに「AccessDenied」エラーが発生する可能性があります。詳細については、「[SageMaker AI リソースにタグ付けのアクセス許可を付与する](security_iam_id-based-policy-examples.md#grant-tagging-permissions)」を参照してください。
SageMaker リソースを作成するためのアクセス許可を付与する [AWS Amazon SageMaker AI の マネージドポリシー](security-iam-awsmanpol.md) には、それらのリソースの作成中にタグを追加するためのアクセス許可もあらかじめ含まれています。
サーバーレスエンドポイントを作成するには、Amazon SageMaker AI コンソール、API、または AWS CLIを使用できます。サーバーレスエンドポイントは、[リアルタイムエンドポイント](realtime-endpoints.md)に似たプロセスを使用して作成できます。
**Topics**
+ [モデルを作成する](serverless-endpoints-create-model.md)
+ [エンドポイント設定を作成する](serverless-endpoints-create-config.md)
+ [エンドポイントを作成する](serverless-endpoints-create-endpoint.md)
# モデルを作成する
モデルを作成するには、モデルのアーティファクトとコンテナイメージの場所を指定する必要があります。[SageMaker モデルレジストリ](model-registry.md)からモデルのバージョンを使用することもできます。次のセクションの例では、[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) API、モデルレジストリ、および [Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)を使用してモデルを作成する方法を説明します。
## モデルを作成するには (モデルレジストリを使用)
[モデルレジストリ](model-registry.md)は、ML パイプラインで使用するモデルのバージョンのカタログを作成し、管理するのに役立つ SageMaker AI の機能です。サーバーレス推論でモデルレジストリを使用するには、最初にモデルレジストリのモデルグループにモデルのバージョンを登録する必要があります。モデルレジストリにモデルを登録する方法については、「[モデルグループを作成する](model-registry-model-group.md)」および「[モデルバージョンを登録する](model-registry-version.md)」の手順に従ってください。
次の例では、登録されたモデルのバージョンの ARN が必要で、[AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) を使用して [CreateModel API](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) を呼び出します。サーバーレス推論の場合、モデルレジストリは現在 AWS SDK for Python (Boto3) でのみサポートされています。サンプルについては、次の値を指定します。
+ `model_name` に、モデルの名前を入力します。
+ `sagemaker_role` には、SageMaker AI が作成したデフォルトのロール、または「[の前提条件を満たす](serverless-endpoints-prerequisites.md)」セクションのステップ 4 でカスタマイズした SageMaker AI IAM ロールを使用できます。
+ `ModelPackageName` には、モデルのバージョンの ARN を指定します。モデルレジストリのモデルグループに登録されている必要があります。
```
#Setup
import boto3
import sagemaker
region = boto3.Session().region_name
client = boto3.client("sagemaker", region_name=region)
#Role to give SageMaker AI permission to access AWS services.
sagemaker_role = sagemaker.get_execution_role()
#Specify a name for the model
model_name = ""
#Specify a Model Registry model version
container_list = [
{
"ModelPackageName":
}
]
#Create the model
response = client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
container_list
)
```
## モデルを作成するには (API を使用)
次の例では、[AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) を使用して [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) API を呼び出します。次の値を指定します。
+ `sagemaker_role,` には、SageMaker AI が作成したデフォルトのロール、または「[の前提条件を満たす](serverless-endpoints-prerequisites.md)」セクションのステップ 4 でカスタマイズした SageMaker AI IAM ロールを使用できます。
+ `model_url` には、Amazon S3 URI をモデルに指定します。
+ `container` には、Amazon ECR パスで使用するコンテナを取得します。この例では、SageMaker AI が提供する XGBoost コンテナを使用します。SageMaker AI コンテナを選択していない場合、または独自のコンテナを使用する場合は、「[の前提条件を満たす](serverless-endpoints-prerequisites.md)」セクションのステップ 6 を参照してください。
+ `model_name` に、モデルの名前を入力します。
```
#Setup
import boto3
import sagemaker
region = boto3.Session().region_name
client = boto3.client("sagemaker", region_name=region)
#Role to give SageMaker AI permission to access AWS services.
sagemaker_role = sagemaker.get_execution_role()
#Get model from S3
model_url = "s3://amzn-s3-demo-bucket/models/model.tar.gz"
#Get container image (prebuilt example)
from sagemaker import image_uris
container = image_uris.retrieve("xgboost", region, "0.90-1")
#Create model
model_name = ""
response = client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
Containers = [{
"Image": container,
"Mode": "SingleModel",
"ModelDataUrl": model_url,
}]
)
```
## モデルを作成するには (コンソールを使用)
1. [Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)にサインインします。
1. [ナビゲーション] タブで、**[Inference]** (推論) を選択します。
1. 次に、**[Models]** (モデル) を選択します。
1. **[モデルの作成]** を選択します。
1. **モデル名**には、アカウントと に固有のモデルの名前を入力します AWS リージョン。
1. **[IAM ロール]** で作成済みの IAM ロール (「[の前提条件を満たす](serverless-endpoints-prerequisites.md)」を参照) を選択するか、SageMaker AI に IAM ロールの作成を許可します。
1. **[Container input option]** (コンテナ入力オプション) の **[Container definition 1]** (コンテナの定義 1) で、**[Provide model artifacts and input location]** (モデルのアーティファクトと入力場所を指定する) を選択します。
1. **[Provide model artifacts and inference image options]** (モデルアーティファクトと推論イメージオプションを指定する) で、**[Use a single model]** (単一のモデルを使用する) を選択します。
1. **[Location of inference code image]** (推論コードイメージの場所) に、コンテナへの Amazon ECR パスを入力します。イメージは、SageMaker AI が提供するファーストパーティーイメージ (TensorFlow、XGBoost など) か、エンドポイントを作成するのと同じアカウント内の Amazon ECR リポジトリに存在するイメージである必要があります。コンテナがない場合は、「[の前提条件を満たす](serverless-endpoints-prerequisites.md)」セクションのステップ 6 に戻り、詳細を参照してください。
1. **[Location of model artifacts]** (モデルアーティファクトの場所) に、ML モデルへの Amazon S3 URI を入力します。例えば、`s3://amzn-s3-demo-bucket/models/model.tar.gz`。
1. (オプション) **[Tags]** (タグ) では、キーバリューペアを追加して、モデルのメタデータを作成します。
1. **[モデルの作成]** を選択します。
# エンドポイント設定を作成する
モデルを作成したら、エンドポイント設定を作成します。その後、エンドポイント設定の仕様を使用してモデルをデプロイできます。設定では、リアルタイムエンドポイントとサーバーレスエンドポイントのどちらを使用するかを指定します。サーバーレスエンドポイント設定を作成するには、[Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)、[CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) API、または AWS CLIを使用できます。API とコンソールのアプローチについては、次のセクションで説明します。
## エンドポイント設定を作成するには (API を使用)
次の例では、[AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) を使用して [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) API を呼び出します。次の値を指定します。
+ `EndpointConfigName` では、エンドポイント設定の名前を選択します。名前は、リージョンのアカウント内で一意である必要があります。
+ (オプション) では`KmsKeyId`、 AWS KMS 使用するキーのキー ID、キー ARN、エイリアス名、またはエイリアス ARN を使用します。SageMaker AI はこのキーを使用して Amazon ECR イメージを暗号化します。
+ `ModelName` では、デプロイするモデルの名前を使用します。これは、「[モデルを作成する](serverless-endpoints-create-model.md)」ステップで使用したものと同じモデルである必要があります。
+ `ServerlessConfig` では
+ `MemorySizeInMB` を `2048` に設定します。この例では、メモリサイズを 2048 MB に設定しますが、メモリサイズには 1024 MB、2048 MB、3072 MB、4096 MB、5120 MB、または 6144 MB のいずれかの値を選択できます。
+ `MaxConcurrency` を `20` に設定します。この例では、最大同時実行数を 20 に設定します。サーバーレスエンドポイントに設定できる同時呼び出しの最大数は 200 で、選択できる最小値は 1 です。
+ (オプション) プロビジョニングされた同時実行性を使用するには、`ProvisionedConcurrency` を 10 に設定します。この例では、プロビジョニングされた同時実行数を 10 に設定します。サーバーレスエンドポイントの `ProvisionedConcurrency` の数は、`MaxConcurrency` 以下である必要があります。オンデマンドのサーバーレス推論エンドポイントを使用する場合は、空のままにしておきます。プロビジョニング同時実行数は動的にスケーリングできます。詳細については、「[サーバーレスエンドポイントのプロビジョニングされた同時実行の自動スケール](serverless-endpoints-autoscale.md)」を参照してください。
```
response = client.create_endpoint_config(
EndpointConfigName="",
KmsKeyId="arn:aws:kms:us-east-1:123456789012:key/143ef68f-76fd-45e3-abba-ed28fc8d3d5e",
ProductionVariants=[
{
"ModelName": "",
"VariantName": "AllTraffic",
"ServerlessConfig": {
"MemorySizeInMB": 2048,
"MaxConcurrency": 20,
"ProvisionedConcurrency": 10,
}
}
]
)
```
## エンドポイント設定を作成するには (コンソールを使用)
1. [Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)にサインインします。
1. [ナビゲーション] タブで、**[Inference]** (推論) を選択します。
1. 次に、**[Endpoint configurations]** (エンドポイント設定) を選択します。
1. **[Create endpoint configuration]** (エンドポイント設定を作成) を選択します。
1. **[Endpoint configuration name]** (エンドポイント設定名) に、リージョンのアカウント内で一意の名前を入力します。
1. **[エンドポイントのタイプ]** で、**[サーバーレス]** を選択します。
![\[コンソールのエンドポイントタイプオプションのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/serverless-endpoints-endpoint-config.png)
1. **[Production variants]** (本番稼働用バリアント) で、**[Add model]** (モデルの追加) を選択します。
1. **[Add model]** (モデルの追加) で、モデルのリストから使用するモデルを選択し、**[Save]** (保存) を選択します。
1. モデルを追加したら、**[Actions]** (アクション)で、**[Edit]** (編集) を選択します。
1. **[Memory size]** (メモリサイズ)で、必要なメモリサイズを GB 単位で選択します。
![\[コンソールのメモリサイズオプションのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/serverless-endpoints-endpoint-config-2.png)
1. **[Max Concurrency]** (最大同時実行数)に、エンドポイントの目的とする最大同時呼び出し数を入力します。入力できる最大値は 200、最小値は 1 です。
1. (オプション) プロビジョニングされた同時実行性を使用するには、**[プロビジョニングされた同時実行数の設定]** フィールドに必要な同時呼び出し数を入力します。プロビジョニングされた同時呼び出しの数は、最大同時呼び出し数以下である必要があります。
1. **[保存]** を選択します。
1. (オプション) エンドポイント設定のメタデータを作成する場合は、**[Tags]** (タグ) にキーバリューペアを入力します。
1. **[Create endpoint configuration]** (エンドポイント設定を作成) を選択します。
# エンドポイントを作成する
サーバーレスエンドポイントを作成するには、[Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)、[CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) API、または AWS CLIを使用できます。API とコンソールのアプローチについては、次のセクションで説明します。エンドポイントを作成すると、エンドポイントが使用可能になるまでに数分かかる場合があります。
## エンドポイントを作成するには (API を使用)
次の例では、[AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) を使用して [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) API を呼び出します。次の値を指定します。
+ `EndpointName` に、アカウントのリージョン内で一意のエンドポイントの名前を入力します。
+ `EndpointConfigName` には、前のセクションで作成したエンドポイント設定の名前を使用します。
```
response = client.create_endpoint(
EndpointName="",
EndpointConfigName=""
)
```
## エンドポイントを作成するには (コンソールを使用)
1. [Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)にサインインします。
1. [ナビゲーション] タブで、**[Inference]** (推論) を選択します。
1. 次に **[Endpoints]** (エンドポイント) を選択します。
1. **[エンドポイントの作成]** を選択します。
1. **[Endpoint name]** (エンドポイント名) に、アカウントのリージョン内で一意の名前を入力します。
1. **[Attach endpoint configuration]** (エンドポイント設定のアタッチ) で、**[Use an existing endpoint configuration]** (既存のエンドポイント設定の使用) を選択します。
1. **[Endpoint configuration]** (エンドポイント設定) で、前のセクションで作成したエンドポイント設定の名前を選択し、**[Select endpoint configuration]** (エンドポイント設定の選択) を選択します。
1. (オプション) エンドポイントのメタデータを作成する場合は、**[Tags]** (タグ) にキーバリューペアを入力します。
1. **エンドポイントの作成** を選択します。
![\[コンソールのエンドポイントの作成と設定ページのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/serverless-endpoints-create.png)
# サーバーレスエンドポイントを呼び出す
サーバーレスエンドポイントを使用して推論を実行するには、エンドポイントに HTTP リクエストを送信する必要があります。[InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) API または を使用して AWS CLI、エンドポイントを呼び出す`POST`リクエストを行うことができます。サーバーレス呼び出しのリクエストとレスポンスペイロードの最大サイズは 4 MB です。サーバーレスエンドポイントの場合:
+ モデルのダウンロードと `/ping` へのサーバーの応答は、3 分以内に行われる必要があります。
+ コンテナが `/invocations` への推論リクエストに応答するためのタイムアウトは 1 分です。
## エンドポイントを呼び出すには
次の例では、[AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) を使用して [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) API を呼び出します。このガイドの他の API コールとは異なり、`InvokeEndpoint` の場合は、SageMaker ランタイムをクライアントとして使用する必要があります。次の値を指定します。
+ `endpoint_name` では、呼び出すインサービスサーバーレスエンドポイントの名前を使用します。
+ `content_type` では、リクエストボディの入力データの MIME タイプを指定します (`application/json` など)。
+ `payload` では、推論のリクエストペイロードを使用します。ペイロードはバイト単位またはファイルのようなオブジェクトでなければなりません。
```
runtime = boto3.client("sagemaker-runtime")
endpoint_name = ""
content_type = ""
payload =
response = runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload
)
```
# サーバーレスエンドポイントを更新する
エンドポイントを更新する前に、新しいエンドポイント設定を作成するか、既存のエンドポイント設定を使用します。エンドポイント設定は、更新の変更を指定する場所です。エンドポイントは [SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)、[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API、または AWS CLIで更新できます。サーバーレスエンドポイントを更新するプロセスは、[リアルタイムエンドポイント](realtime-endpoints.md)の更新プロセスと同じです。SageMaker AI はコンテナとモデルを再初期化する必要があるため、エンドポイントの更新時、エンドポイントにリクエストを行うときにコールドスタートが発生する場合があります。
オンデマンドのサーバーレスエンドポイントを、プロビジョニングされた同時実行性を使用するサーバーレスエンドポイントに更新するか、プロビジョニングされた同時実行性を使用する既存のサーバーレスエンドポイントに合わせてプロビジョニングされた同時実行数の値を調整することができます。どちらの場合も、必要なプロビジョニングされた同時実行数の値を使用して新しいサーバーレスエンドポイント設定を作成し、`UpdateEndpoint` を既存のサーバーレスエンドポイントに適用する必要があります。プロビジョニングされた同時実行性を使用して新しいサーバーレスエンドポイント設定を作成する方法の詳細については、「[エンドポイント設定を作成する](serverless-endpoints-create-config.md)」を参照してください。
サーバーレスエンドポイントからプロビジョニングされた同時実行性を削除する場合、プロビジョニングされた同時実行数の値を指定せずに新しいエンドポイント設定を作成し、`UpdateEndpoint` をエンドポイントに適用する必要があります。
**注記**
リアルタイム推論エンドポイントをオンデマンドのサーバーレスエンドポイントまたはプロビジョニングされた同時実行性を使用したサーバーレスエンドポイントに更新することは、現在サポートされていません。
## エンドポイントを更新する
新しいサーバーレスエンドポイント設定を作成した後、[AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) または [SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/)を使用して既存のサーバーレスエンドポイントを更新できます。 AWS SDK for Python (Boto3) と SageMaker AI コンソールを使用してエンドポイントを更新する方法の例については、以下のセクションで説明します。
### エンドポイントを更新するには (Boto3 を使用)
次の例では、[AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) を使用し、[update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/update_endpoint.html) メソッドを呼び出します。メソッドを呼び出すときは、少なくとも次のパラメータを指定します。
+ `EndpointName` には、更新するエンドポイントの名前を使用します。
+ `EndpointConfigName` には、更新に使用するエンドポイント設定の名前を使用します。
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
)
```
### エンドポイントを更新するには (コンソールを使用)
1. [Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/)にサインインします。
1. [ナビゲーション] タブで、**[Inference]** (推論) を選択します。
1. 次に **[Endpoints]** (エンドポイント) を選択します。
1. エンドポイントのリストから、更新するエンドポイントを選択します。
1. **[エンドポイント設定の指定]** セクションで **[変更]** を選択します。
1. **[Change the Endpoint configuration]** (エンドポイント設定の変更) で、**[Use an existing endpoint configuration]** (既存のエンドポイント設定の使用) を選択します。
1. エンドポイント設定のリストから、更新に使用するエンドポイント設定を選択します。
1. **[Select endpoint configuration]** (エンドポイント設定の選択) を選択します。
1. **[Update endpoint]** (エンドポイントの更新) を選択します。
# サーバーレスエンドポイントを記述する
エンドポイントの ARN、現在のステータス、デプロイ設定、失敗の理由などの詳細を含むエンドポイントに関する情報を取得できます。[SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)、[DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) API、または AWS CLIを使用して、エンドポイントに関する情報を見つけることができます。
## エンドポイントを記述するには (API を使用)
次の例では、[AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#id309) を使用して [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) API を呼び出します。`EndpointName` には、チェックするエンドポイントの名前を使用します。
```
response = client.describe_endpoint(
EndpointName="",
)
```
## エンドポイントを記述するには (コンソールを使用)
1. [Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)にサインインします。
1. [ナビゲーション] タブで、**[Inference]** (推論) を選択します。
1. 次に **[Endpoints]** (エンドポイント) を選択します。
1. エンドポイントのリストから、チェックするエンドポイントを選択します。
エンドポイントページには、エンドポイントに関する情報が含まれています。
# サーバーレスエンドポイントを削除する
[SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)、[DeleteEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) API、または AWS CLIを使用して、サーバーレスエンドポイントを削除できます。以下の例は、API と SageMaker AI コンソールを使用してエンドポイントを削除する方法を示しています。
## エンドポイントを削除するには (API を使用)
次の例では、[AWS SDK for Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) を使用して [DeleteEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) API を呼び出します。`EndpointName` には、削除するサーバーレスエンドポイントの名前を使用します。
```
response = client.delete_endpoint(
EndpointName="",
)
```
## エンドポイントを削除するには (コンソールを使用)
1. [Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/home)にサインインします。
1. [ナビゲーション] タブで、**[Inference]** (推論) を選択します。
1. 次に **[Endpoints]** (エンドポイント) を選択します。
1. エンドポイントのリストから、削除するエンドポイントを選択します。
1. **[Actions]** (アクション) ドロップダウンリストを選択してから、**[Delete]** (削除) を選択します。
1. プロンプトが表示されたら、**[Delete]** (削除) を選択します。
エンドポイントの削除プロセスが開始します。
# サーバーレスエンドポイントからメトリクスを追跡するためのアラームとログ
サーバーレスエンドポイントをモニタリングするには、Amazon CloudWatch アラームを使用できます。CloudWatch は、AWS アプリケーションとリソースからメトリクスをリアルタイムで収集するサービスです。アラームは収集されたメトリックをモニタリングし、しきい値とそのしきい値を超えた場合に実行するアクションを事前に指定することができます。例えば、エンドポイントがエラーしきい値を超えた場合、CloudWatch アラームから通知を送信できます。CloudWatch アラームを設定することで、エンドポイントのパフォーマンスと機能を可視化できます。CloudWatch アラームの使用の詳細については、*Amazon CloudWatch ユーザーガイド*の「[Amazon CloudWatch アラームの使用](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)」を参照してください。
## CloudWatch によるモニタリング
次のメトリクスは、サーバーレスエンドポイントに対するメトリクスの網羅的なリストです。以下にリストされていないメトリクスは、サーバーレスエンドポイントに対して発行されません。次のメトリクスの詳細については、「[Monitor Amazon SageMaker AI with Amazon CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html)」を参照してください。
### 共通のエンドポイントメトリクス
これらの CloudWatch メトリクスは、リアルタイムエンドポイントについて発行されるメトリクスと同じです。
`OverheadLatency` メトリクスは、サーバーレスエンドポイントの新しいコンピューティングリソースの起動にかかるコールドスタート時間を含む、SageMaker AI が追加したすべての追加のレイテンシーを追跡します。オンデマンドのサーバーレスエンドポイントと比較すると、プロビジョニングされた同時実行を備えたサーバーレスエンドポイントの `OverheadLatency` は、一般的に大幅に短くなります。
サーバーレスエンドポイントは、`Invocations4XXErrors`、`Invocations5XXErrors`、`Invocations`、`ModelLatency`、`ModelSetupTime`、`MemoryUtilization` メトリクスを使用することもできます。これらのメトリクスの詳細については、「[SageMaker AI エンドポイント呼び出しメトリクス](monitoring-cloudwatch.md#cloudwatch-metrics-endpoint-invocation)」を参照してください。
### 共通のサーバーレスエンドポイントのメトリクス
これらの CloudWatch メトリクスは、オンデマンドのサーバーレスエンドポイントとプロビジョニングされた同時実行を備えたサーバーレスエンドポイントの両方に発行されます。
| メトリクス名 | 説明 | 単位/統計 |
| --- | --- | --- |
| ServerlessConcurrentExecutionsUtilization | 同時実行数を最大同時実行数で割った値。 | 単位: なし有効な統計: Average、Max、Min |
### プロビジョニングされた同時実行メトリクスを備えたサーバーレスエンドポイント
これらの CloudWatch メトリクスは、プロビジョニングされた同時実行を備えたサーバーレスエンドポイントに発行されます。
| メトリクス名 | 説明 | 単位/統計 |
| --- | --- | --- |
| ServerlessProvisionedConcurrencyExecutions | エンドポイントが処理する同時実行数。 | 単位: カウント有効な統計: Average、Max、Min |
| ServerlessProvisionedConcurrencyUtilization | 同時実行数を割り当て済みのプロビジョニングされた同時実行数で割った値。 | 単位: なし有効な統計: Average、Max、Min |
| ServerlessProvisionedConcurrencyInvocations | プロビジョニングされた同時実行が処理した InvokeEndpoint リクエストの数。 | 単位: カウント有効な統計: Average、Max、Min |
| ServerlessProvisionedConcurrencySpilloverInvocations | プロビジョニングされた同時実行で処理されず、オンデマンドのサーバーレス推論によって処理された InvokeEndpoint リクエストの数。 | 単位: カウント有効な統計: Average、Max、Min |
## ログ
エンドポイントからのログをデバッグ用または進行状況分析用にモニタリングする場合は、Amazon CloudWatch Logs を使用できます。サーバーレスエンドポイントに使用できる SageMaker AI が提供するロググループは `/aws/sagemaker/Endpoints/[EndpointName]` です。SageMaker AI での CloudWatch Logs の使用方法の詳細については、「[Amazon SageMaker AI 用 CloudWatch Logs](logging-cloudwatch.md)」を参照してください。CloudWatch Logs の詳細については、*Amazon CloudWatch Logs ユーザーガイド*の「[Amazon CloudWatch Logs とは](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html)」を参照してください。
# サーバーレスエンドポイントのプロビジョニングされた同時実行の自動スケール
Amazon SageMaker AI は、オンデマンドのサーバーレスエンドポイントを自動的にスケールインまたはスケールアウトします。プロビジョニングされた同時実行を使用するサーバーレスエンドポイントでは、Application Auto Scaling を使用して、トラフィックプロファイルに基づいてプロビジョニングされた同時実行をスケールアップまたはスケールダウンできるため、コストを最適化できます。
サーバーレスエンドポイントでプロビジョニングされた同時実行を自動スケールするための前提条件は次のとおりです。
+ [モデルの登録](#serverless-endpoints-autoscale-register)
+ [スケーリングポリシーを定義する](#serverless-endpoints-autoscale-define)
+ [スケーリングポリシーを適用する](#serverless-endpoints-autoscale-apply)
自動スケーリングを使用する前に、プロビジョニングされた同時実行を使用してサーバーレスエンドポイントにモデルをデプロイしておく必要があります。デプロイされたモデルは、[本番稼動用バリアント](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html)と呼ばれます。プロビジョ二ングされた同時実行を使用したサーバーレスエンドポイントにモデルをデプロイする方法の詳細については、「[エンドポイント設定を作成する](serverless-endpoints-create-config.md)」および「[エンドポイントを作成する](serverless-endpoints-create-endpoint.md)」を参照してください。スケーリングポリシーのメトリクスとターゲット値を指定するには、スケーリングポリシーを設定する必要があります。スケーリングポリシーを定義する方法の詳細については、「[スケーリングポリシーを定義する](#serverless-endpoints-autoscale-define)」を参照してください。モデルを登録してスケーリングポリシーを定義した後に、そのスケーリングポリシーを登録されたモデルに適用します。スケーリングポリシーを適用する方法の詳細については、「[スケーリングポリシーを適用する](#serverless-endpoints-autoscale-apply)」を参照してください。
オートスケーリングに関わるその他の前提条件およびコンポーネントの詳細については、[SageMaker AI オートスケーリングに関するドキュメント](endpoint-auto-scaling.md)の「[自動スケーリングの前提条件](endpoint-auto-scaling-prerequisites.md)」セクションを参照してください。
## モデルの登録
プロビジョニングされた同時実行を使用してサーバーレスエンドポイントに自動スケーリングを追加するには、まず AWS CLI または Application Auto Scaling API を使用してモデル (本番稼動用バリアント) を登録する必要があります。
### モデルの登録 (AWS CLI)
モデルを登録するには、次のパラメータで `register-scalable-target` AWS CLI コマンドを使用します。
+ `--service-namespace` – この値を `sagemaker` に設定します。
+ `--resource-id` – モデルのリソース識別子 (具体的には本番稼働用バリアント)。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子は本番稼働用バリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `--scalable-dimension` – この値を `sagemaker:variant:DesiredProvisionedConcurrency` に設定します。
+ `--min-capacity` – モデルのプロビジョニングされた同時実行の最小数。`--min-capacity` を 1 以上に設定します。`--max-capacity` で指定した値以下にする必要があります。
+ `--max-capacity` – Application Auto Scaling を通じて有効にする必要があるプロビジョニングされた同時実行の最大数。`--max-capacity` の最小数を 1 に設定します。この値は、`--min-capacity` で指定した値以上にする必要があります。
次の例は、プロビジョニングされた同時実行の値が 1～10 になるように動的にスケールされる、`MyVariant` という名前のモデルを登録する方法を示します。
```
aws application-autoscaling register-scalable-target \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--min-capacity 1 \
--max-capacity 10
```
### モデルの登録 (Application Auto Scaling API)
モデルを登録するには、`RegisterScalableTarget` Application Auto Scaling API アクションを次のパラメータで使用します。
+ `ServiceNamespace` – この値を `sagemaker` に設定します。
+ `ResourceId` – モデルのリソース識別子 (具体的には本番稼働用バリアント)。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子は本番稼働用バリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `ScalableDimension` – この値を `sagemaker:variant:DesiredProvisionedConcurrency` に設定します。
+ `MinCapacity` – モデルのプロビジョニングされた同時実行の最小数。`MinCapacity` を 1 以上に設定します。`MaxCapacity` で指定した値以下にする必要があります。
+ `MaxCapacity` – Application Auto Scaling を通じて有効にする必要があるプロビジョニングされた同時実行の最大数。`MaxCapacity` の最小数を 1 に設定します。この値は、`MinCapacity` で指定した値以上にする必要があります。
次の例は、プロビジョニングされた同時実行の値が 1～10 になるように動的にスケールされる、`MyVariant` という名前のモデルを登録する方法を示します。
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.RegisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndPoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"MinCapacity": 1,
"MaxCapacity": 10
}
```
## スケーリングポリシーを定義する
スケーリングポリシーのメトリクスとターゲット値を指定するには、ターゲット追跡スケーリングポリシーを設定できます。スケーリングポリシーを JSON ブロックとしてテキストファイルに定義します。その後、AWS CLI または Application Auto Scaling API を呼び出す際に、このテキストファイルを使用することができます。サーバーレスエンドポイントのターゲット追跡スケーリングポリシーを時間をかけずに定義するには、事前定義された `SageMakerVariantProvisionedConcurrencyUtilization` メトリクスを使用します。
```
{
"TargetValue": 0.5,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantProvisionedConcurrencyUtilization"
},
"ScaleOutCooldown": 1,
"ScaleInCooldown": 1
}
```
## スケーリングポリシーを適用する
モデルを登録した後、プロビジョニングされた同時実行を使用してサーバーレスエンドポイントにスケーリングポリシーを適用できます。定義したターゲット追跡スケーリングポリシーを適用するには、「[ターゲット追跡スケーリングポリシーの適用](#serverless-endpoints-autoscale-apply-target)」を参照してください。サーバーレスエンドポイントへのトラフィックフローに予測可能なルーチンがある場合は、ターゲット追跡スケーリングポリシーを適用する代わりに、特定の時間にスケーリングアクションをスケジュールすることもできます。スケーリングアクションのスケジュールに関する詳細については、「[スケジュールに基づくスケーリング](#serverless-endpoints-autoscale-apply-scheduled)」を参照してください。
### ターゲット追跡スケーリングポリシーの適用
AWS マネジメントコンソール、AWS CLI、または Application Auto Scaling API を使用して、プロビジョニングされた同時実行を使用するサーバーレスエンドポイントにターゲット追跡スケーリングポリシーを適用できます。
#### ターゲット追跡スケーリングポリシーの適用 (AWS CLI)
スケーリングポリシーをモデルに適用するには、次のパラメータで `put-scaling-policy` AWS CLI; コマンドを使用します。
+ `--policy-name` – スケーリングポリシーの名前。
+ `--policy-type` この値は に設定します。`TargetTrackingScaling`
+ `--resource-id` – バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `--service-namespace` この値は に設定します。`sagemaker`
+ `--scalable-dimension` この値は に設定します。`sagemaker:variant:DesiredProvisionedConcurrency`
+ `--target-tracking-scaling-policy-configuration` – モデルに使用するターゲット追跡スケーリングポリシー設定。
次の例では、`MyScalingPolicy` というターゲット追跡スケーリングポリシーを `MyVariant` という名前のモデルに適用する方法を示します。ポリシー設定は `scaling-policy.json` という名前のファイルに保存されます。
```
aws application-autoscaling put-scaling-policy \
--policy-name MyScalingPolicy \
--policy-type TargetTrackingScaling \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--target-tracking-scaling-policy-configuration file://[file-localtion]/scaling-policy.json
```
#### ターゲット追跡スケーリングポリシーの適用 (Application Auto Scaling API)
モデルにスケーリングポリシーを適用するには、次のパラメータを指定して `PutScalingPolicy` Application Auto Scaling API アクションを使用します。
+ `PolicyName` – スケーリングポリシーの名前。
+ `PolicyType` この値は に設定します。`TargetTrackingScaling`
+ `ResourceId` – バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `ServiceNamespace` この値は に設定します。`sagemaker`
+ `ScalableDimension` この値は に設定します。`sagemaker:variant:DesiredProvisionedConcurrency`
+ `TargetTrackingScalingPolicyConfiguration` – モデルに使用するターゲット追跡スケーリングポリシー設定。
次の例では、`MyScalingPolicy` というターゲット追跡スケーリングポリシーを `MyVariant` という名前のモデルに適用する方法を示します。ポリシー設定は `scaling-policy.json` という名前のファイルに保存されます。
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.PutScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "MyScalingPolicy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"PolicyType": "TargetTrackingScaling",
"TargetTrackingScalingPolicyConfiguration":
{
"TargetValue": 0.5,
"PredefinedMetricSpecification":
{
"PredefinedMetricType": "SageMakerVariantProvisionedConcurrencyUtilization"
}
}
}
```
#### ターゲット追跡スケーリングポリシーの適用 (AWS マネジメントコンソール)
ターゲット追跡スケーリングポリシーを AWS マネジメントコンソール で適用するには:
1. [Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/)にサインインします。
1. ナビゲーションタブで、**[推論]** を選択します。
1. **[エンドポイント]** を選択し、すべてのエンドポイントのリストを表示します。
1. スケーリングポリシーを適用するエンドポイントを選択します。エンドポイントの設定を含むページが表示され、モデル (本番稼働用バリアント) が **[エンドポイントランタイム設定セクション]** に一覧表示されます。
1. スケーリングポリシーを適用する本番稼働用バリアントを選択し、**[自動スケーリングの設定]** を選択します。**[バリアントの自動スケーリングの設定]** ダイアログボックスが表示されます。
![\[コンソールのバリアントの自動スケーリングの設定ダイアログボックスのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/serverless-endpoints-variant-autoscaling.png)
1. プロビジョニングされた同時実行の最小値と最大値を、**[バリアントの自動スケーリング]** セクションの **[プロビジョニングされた同時実行の最小値]** フィールドと **[プロビジョニングされた同時実行の最大値]** フィールドに、それぞれ入力します。プロビジョニングされた同時実行の最小値は、プロビジョニングされた同時実行の最大値以下である必要があります。
1. ターゲットメトリクス `SageMakerVariantProvisionedConcurrencyUtilization` の **[ターゲット値]** フィールドに、ターゲット値を入力します。
1. (オプション) **[スケールインクールダウン]** フィールドと **[スケールアウトクールダウン]** フィールドに、スケールインクールダウンとスケールアウトクールダウンの値 (秒) をそれぞれ入力します。
1. (オプション) トラフィックが減少したときに自動スケーリングでインスタンスが削除されないようにするには、**[スケールインを無効にする]** を選択します。
1. **[保存]** を選択します。
### スケジュールに基づくスケーリング
プロビジョニングされた同時実行を使用するサーバーレスエンドポイントへのトラフィックがルーチンパターンに従っている場合は、特定の時間にスケーリングアクションをスケジュールして、プロビジョニングされた同時実行をスケールインまたはスケールアウトする場合があります。AWS CLI または Application Auto Scaling を使用してスケーリングアクションをスケジュールできます。
#### スケジュールされたスケーリング (AWS CLI)
スケーリングポリシーをモデルに適用するには、次のパラメータで `put-scheduled-action` AWS CLI; コマンドを使用します。
+ `--schedule-action-name` – スケーリングアクションの名前。
+ `--schedule` – スケーリングアクションの開始時間と終了時間を定期的なスケジュールで指定する cron 式。
+ `--resource-id` – バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `--service-namespace` この値は に設定します。`sagemaker`
+ `--scalable-dimension` この値は に設定します。`sagemaker:variant:DesiredProvisionedConcurrency`
+ `--scalable-target-action` – スケーリングアクションのターゲット。
次の例は、`MyVariant` という名前のモデルに `MyScalingAction` という名前のスケーリングアクションを定期的なスケジュールで追加する方法を示しています。指定されたスケジュール (毎日午後 12:15 UTC) で、現在のプロビジョニングされた同時実行が `MinCapacity` で指定された値を下回っている場合。Application Auto Scaling は、プロビジョニングされた同時実行を `MinCapacity` で指定された値にスケールアウトします。
```
aws application-autoscaling put-scheduled-action \
--scheduled-action-name 'MyScalingAction' \
--schedule 'cron(15 12 * * ? *)' \
--service-namespace sagemaker \
--resource-id endpoint/MyEndpoint/variant/MyVariant \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--scalable-target-action 'MinCapacity=10'
```
#### スケジュールされたスケーリング (Application Auto Scaling API)
モデルにスケーリングポリシーを適用するには、次のパラメータを指定して `PutScheduledAction` Application Auto Scaling API アクションを使用します。
+ `ScheduleActionName` – スケーリングアクションの名前。
+ `Schedule` – スケーリングアクションの開始時間と終了時間を定期的なスケジュールで指定する cron 式。
+ `ResourceId` – バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `ServiceNamespace` この値は に設定します。`sagemaker`
+ `ScalableDimension` この値は に設定します。`sagemaker:variant:DesiredProvisionedConcurrency`
+ `ScalableTargetAction` – スケーリングアクションのターゲット。
次の例は、`MyVariant` という名前のモデルに `MyScalingAction` という名前のスケーリングアクションを定期的なスケジュールで追加する方法を示しています。指定されたスケジュール (毎日午後 12:15 UTC) で、現在のプロビジョニングされた同時実行が `MinCapacity` で指定された値を下回っている場合。Application Auto Scaling は、プロビジョニングされた同時実行を `MinCapacity` で指定された値にスケールアウトします。
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.PutScheduledAction
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ScheduledActionName": "MyScalingAction",
"Schedule": "cron(15 12 * * ? *)",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
"ScalableTargetAction": "MinCapacity=10"
}
}
}
```
# クリーンアップ
プロビジョニングされた同時実行によるサーバーレスエンドポイントの自動スケーリングを使用し終わったら、作成したリソースをクリーンアップする必要があります。これには、スケーリングポリシーの削除と、Application Auto Scaling からのモデルの登録解除が含まれます。クリーンアップすることで、使用していないリソースに不必要なコストが発生しなくなります。
## スケーリングポリシーを削除する
AWS マネジメントコンソール、AWS CLI、または Application Auto Scaling API を使用してスケーリングポリシーを削除できます。AWS マネジメントコンソール を使用してスケーリングポリシーを削除する方法の詳細については、[SageMaker AI 自動スケーリングドキュメント](endpoint-auto-scaling.md)の「[スケーリングポリシーを削除する](endpoint-auto-scaling-delete.md)」を参照してください。
### スケーリングポリシーを削除する (AWS CLI)
スケーリングポリシーをモデルに適用するには、次のパラメータで `delete-scaling-policy` AWS CLI; コマンドを使用します。
+ `--policy-name` – スケーリングポリシーの名前。
+ `--resource-id` – バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `--service-namespace` この値は に設定します。`sagemaker`
+ `--scalable-dimension` この値は に設定します。`sagemaker:variant:DesiredProvisionedConcurrency`
次の例では、`MyVariant` という名前のモデルから `MyScalingPolicy` という名前のスケーリングポリシーを削除します。
```
aws application-autoscaling delete-scaling-policy \
--policy-name MyScalingPolicy \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant
```
### スケーリングポリシーを削除する (Application Auto Scaling API)
モデルにスケーリングポリシーを削除するには、次のパラメータで `DeleteScalingPolicy` Application Auto Scaling API アクションを使用します。
+ `PolicyName` – スケーリングポリシーの名前。
+ `ResourceId` – バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `ServiceNamespace` この値は に設定します。`sagemaker`
+ `ScalableDimension` この値は に設定します。`sagemaker:variant:DesiredProvisionedConcurrency`
次の例では、Application Auto Scaling API を使用して、`MyVariant` という名前のモデルから `MyScalingPolicy` というスケーリングポリシーを削除します。
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeleteScalingPolicy
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"PolicyName": "MyScalingPolicy",
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
}
```
## モデルの登録解除
AWS マネジメントコンソール、AWS CLI または Application Auto Scaling API を使用して、モデルを登録解除できます。
### モデルの登録解除 (AWS CLI)
Application Auto Scaling からモデルを登録解除するには、次のパラメータで、`deregister-scalable-target` AWS CLI; コマンドを使用します。
+ `--resource-id` – バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `--service-namespace` この値は に設定します。`sagemaker`
+ `--scalable-dimension` この値は に設定します。`sagemaker:variant:DesiredProvisionedConcurrency`
次の例では、Application Auto Scaling から `MyVariant` という名前のモデルを登録解除します。
```
aws application-autoscaling deregister-scalable-target \
--service-namespace sagemaker \
--scalable-dimension sagemaker:variant:DesiredProvisionedConcurrency \
--resource-id endpoint/MyEndpoint/variant/MyVariant
```
### モデルの登録解除 (Application Auto Scaling API)
Application Auto Scaling からモデルの登録を解除するには、次のパラメータを指定して `DeregisterScalableTarget` Application Auto Scaling API アクションを使用します。
+ `ResourceId` – バリアントのリソース識別子。このパラメータでは、リソースタイプは `endpoint` で、一意の識別子はバリアントの名前です。例: `endpoint/MyEndpoint/variant/MyVariant`。
+ `ServiceNamespace` この値は に設定します。`sagemaker`
+ `ScalableDimension` この値は に設定します。`sagemaker:variant:DesiredProvisionedConcurrency`
次の例では、Application Auto Scaling API を使用して、`MyVariant` という名前のモデルを Application Auto Scaling から登録解除します。
```
POST / HTTP/1.1
Host: autoscaling.us-east-2.amazonaws.com
Accept-Encoding: identity
X-Amz-Target: AnyScaleFrontendService.DeregisterScalableTarget
X-Amz-Date: 20160506T182145Z
User-Agent: aws-cli/1.10.23 Python/2.7.11 Darwin/15.4.0 botocore/1.4.8
Content-Type: application/x-amz-json-1.1
Authorization: AUTHPARAMS
{
"ServiceNamespace": "sagemaker",
"ResourceId": "endpoint/MyEndpoint/variant/MyVariant",
"ScalableDimension": "sagemaker:variant:DesiredProvisionedConcurrency",
}
```
### モデルの登録解除 (AWS マネジメントコンソール)
AWS マネジメントコンソール でモデル (本番稼働用バリアント) の登録を解除するには:
1. [Amazon SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/)を開きます。
1. [ナビゲーション] タブで、**[推論]** を選択します。
1. **[エンドポイント]** を選択すると、エンドポイントのリストが表示されます。
1. 本番稼働用バリアントをホストするサーバーレスエンドポイントを選択します。エンドポイントの設定を含むページが表示され、**[エンドポイントのランタイム設定]** セクションに本番稼働用バリアントが一覧表示されます。
1. 登録を解除する本番稼働用バリアントを選択し、**[自動スケーリングの設定]** を選択します。**[バリアントの自動スケーリングの設定]** ダイアログボックスが表示されます。
1. [**Auto Scaling の登録解除**] を選択します。
# トラブルシューティング
**重要**
Amazon SageMaker Studio または Amazon SageMaker Studio Classic に Amazon SageMaker リソースの作成を許可するカスタム IAM ポリシーでは、これらのリソースにタグを追加するアクセス許可も付与する必要があります。Studio と Studio Classic は、作成したリソースに自動的にタグ付けするため、リソースにタグを追加するアクセス許可が必要になります。IAM ポリシーで Studio と Studio Classic によるリソースの作成が許可されていても、タグ付けが許可されていない場合は、リソースを作成しようとしたときに「AccessDenied」エラーが発生する可能性があります。詳細については、「[SageMaker AI リソースにタグ付けのアクセス許可を付与する](security_iam_id-based-policy-examples.md#grant-tagging-permissions)」を参照してください。
SageMaker リソースを作成するためのアクセス許可を付与する [AWS Amazon SageMaker AI の マネージドポリシー](security-iam-awsmanpol.md) には、それらのリソースの作成中にタグを追加するためのアクセス許可もあらかじめ含まれています。
サーバーレス推論で問題が発生した場合は、次のトラブルシューティングのヒントを参照してください。
## コンテナの問題
サーバーレスエンドポイントに使用するコンテナが、インスタンスベースのエンドポイントで使用したものと同じである場合、コンテナにファイルを書き込む許可がない可能性があります。これは、次のような理由で発生します。
+ サーバーレスエンドポイントが、ping ヘルスチェックの失敗により、作成または更新に失敗する。
+ エンドポイントの Amazon CloudWatch ログに、アクセス許可エラーのためにコンテナが一部のファイルやディレクトリへの書き込みに失敗していることが示される。
この問題を修正するには、ファイルまたはディレクトリに `other` の読み取り、書き込み、実行アクセス許可を追加して、コンテナを再構築してみてください。この手順を完了するには、次のステップを実行します。
1. コンテナの構築に使用した Dockerfile に、次のコマンドを追加します。`RUN chmod o+rwX `。
1. コンテナを再構築します。
1. 新しいコンテナイメージを Amazon ECR にアップロードします。
1. サーバーレスエンドポイントを再度作成または更新してみてください。
# 非同期推論
Amazon SageMaker 非同期推論は、受信リクエストをキューに入れて非同期で処理する SageMaker AI の機能です。このオプションは、ペイロードサイズが大きく (最大 1 GB)、処理時間が長い (最大 1 時間)、ほぼリアルタイムのレイテンシー要件があるリクエストに最適です。非同期推論では、処理するリクエストがない場合、インスタンスカウントをゼロにオートスケーリングすることによりコストを節約できるため、エンドポイントがリクエストを処理している場合にのみ料金が発生します。
## 仕組み
非同期推論エンドポイントの作成は、リアルタイムの推論エンドポイントの作成に似ています。既存の SageMaker AI モデルを使用でき、必要なのは、エンドポイントの設定を作成する際に、`CreateEndpointConfig` API の `EndpointConfig` フィールドで `AsyncInferenceConfig` オブジェクトを指定することだけです。次の図は、非同期推論のアーキテクチャとワークフローを示しています。
![\[ユーザーがどのようにエンドポイントを呼び出すかを示す非同期推論のアーキテクチャ図。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/async-architecture.png)
エンドポイントを呼び出すには、リクエストペイロードを Amazon S3 に配置する必要があります。また、このペイロードへのポインタを `InvokeEndpointAsync` リクエストの一部として指定する必要があります。呼び出しとともに、SageMaker AI は処理のリクエストをキューに入れ、識別子と出力場所をレスポンスとして返します。処理時に、SageMaker AI は所定の Amazon S3 ロケーションに結果を配置します。成功またはエラー通知を Amazon SNS で受け取るようにオプションで選択することもできます。非同期通知の設定方法の詳細については、「[予測結果をチェックする](async-inference-check-predictions.md)」を参照してください。
**注記**
エンドポイント設定に非同期推論の設定 (`AsyncInferenceConfig`) オブジェクトが含まれているということは、エンドポイントで受け取ることができるのは非同期呼び出しのみということを意味します。
## 使用を開始する方法をお知りになりたいですか?
Amazon SageMaker 非同期推論を初めて使用する場合は、次のことを行うことをお勧めします。
+ 非同期エンドポイントを作成、呼び出し、更新、削除する方法の詳細については、「[非同期エンドポイントオペレーション](async-inference-create-invoke-update-delete.md)」を参照してください。
+ [aws/amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) GitHub リポジトリで、[非同期推論のサンプルノートブック](https://github.com/aws/amazon-sagemaker-examples/blob/main/async-inference/Async-Inference-Walkthrough.ipynb)を詳しく見てください。
この [Exclusions](deployment-guardrails-exclusions.md) ページにリストされているいずれかの機能をエンドポイントで使用する場合は、非同期推論を使用できないことにご注意ください。
# 非同期エンドポイントオペレーション
このガイドでは、非同期エンドポイント作成のために満たす必要のある前提条件と、非同期エンドポイントの作成、呼び出し、削除方法について説明します。 AWS SDKs と [Amazon SageMaker Python SDK ](https://sagemaker.readthedocs.io/en/stable/overview.html#sagemaker-asynchronous-inference)を使用して、非同期エンドポイントを作成、更新、削除、および呼び出すことができます。
**Topics**
+ [の前提条件を満たす](async-inference-create-endpoint-prerequisites.md)
+ [非同期推論エンドポイントを作成する方法](async-inference-create-endpoint.md)
+ [非同期エンドポイントを呼び出す](async-inference-invoke-endpoint.md)
+ [非同期エンドポイントを更新する](async-inference-update-endpoint.md)
+ [非同期エンドポイントを削除する](async-inference-delete-endpoint.md)
# の前提条件を満たす
このトピックでは、非同期エンドポイントを作成する前に満たす必要がある前提条件について説明します。これらの前提条件には、モデルアーティファクトの適切な保存、正しいアクセス許可を持つ AWS IAM の設定、コンテナイメージの選択が含まれます。
**前提条件を完了する方法**
1. **Amazon SageMaker AI 用の IAM ロールを作成する。**
非同期推論では、Amazon S3 バケット URI にアクセスする必要があります。これを簡単に行うには、SageMaker AI を実行でき、Amazon S3 と Amazon SNS にアクセスする許可を持つ IAM ロールを作成します。このロールを使用すると、SageMaker AI はお使いのアカウントの下で動作し、Amazon S3 バケットと Amazon SNS トピックにアクセスできます。
IAM ロールを作成するには、IAM コンソール AWS SDK for Python (Boto3)、または を使用します AWS CLI。次の例は、IAM ロールを作成し、IAM コンソールで必要なポリシーをアタッチする方法を示しています。
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソールを開きます。
1. IAM コンソールのナビゲーションペインで、**[ロール]**、**[ロールを作成]** の順に選択します。
1. **[信頼できるエンティティの種類の選択]** で、**[AWS サービス]** を選択します。
1. このロールを引き受けることを許可するサービスを選択します。この場合は、**[SageMaker AI]** を選択します。その後、**[Next: Permissions (次へ: アクセス許可)]** を選択します。
+ これにより、Amazon S3、Amazon ECR、CloudWatch Logs などの関連サービスへのアクセス許可を付与する IAM ポリシーが自動的に作成されます。
1. [**次へ: タグ**] を選択します。
1. (オプション) タグをキーバリューのペアとしてアタッチして、メタデータをロールに追加します。IAM でのタグの使用の詳細については、「[IAM リソースのタグ付け](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html)」を参照してください。
1. **[次へ: レビュー]** を選択します。
1. **[Role name]** (ロール名) を入力します。
1. 可能な場合は、ロール名またはロール名のサフィックスを入力します。ロール名は AWS アカウント内で一意である必要があります。大文字と小文字は区別されません。例えば、`PRODROLE` と `prodrole` というロール名を両方作成することはできません。他の AWS リソースはロールを参照する可能性があるため、ロールの作成後にロールの名前を編集することはできません。
1. (オプション) [**Role description**] に、新しいロールの説明を入力します。
1. ロール情報を確認し、**ロールの作成** を選択します。
SageMaker AI ロールの ARN をメモしておきます。コンソールを使用してロールの ARN を見つけるには、次を実行します。
1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) に移動します。
1. **[Roles]** (ロール) を選択します。
1. [Search] (検索) フィールドにロール名を入力して、先ほど作成したロールを検索します。
1. ロールを選択します。
1. ロールの ARN は、**[Summary]** (概要) ページの上部にあります。
1. **Amazon SageMaker AI、Amazon S3、Amazon SNS の許可を IAM ロールに追加します。**
ロールが作成されたら、SageMaker AI、Amazon S3 の許可と、オプションで Amazon SNS の許可を IAM ロールに付与します。
IAM コンソールで、**[Roles]** (ロール) を選択します。**[Search]** (検索) フィールドにロール名を入力して、作成したロールを検索します。
1. ロールを選択します。
1. 次に、**[Attach policies]** (ポリシーをアタッチ) を選択します。
1. Amazon SageMaker 非同期推論では、アクション `"sagemaker:CreateModel"`、`"sagemaker:CreateEndpointConfig"`、`"sagemaker:CreateEndpoint"`、`"sagemaker:InvokeEndpointAsync"` を実行する許可が必要です。
これらのアクションは `AmazonSageMakerFullAccess` ポリシーに含まれています。このポリシーを IAM ロールに追加します。**[Search]** (検索) フィールドで `AmazonSageMakerFullAccess` を検索します。`AmazonSageMakerFullAccess` を選択します。
1. **[Attach policy]** (ポリシーのアタッチ) を選択します。
1. 次に **[Attach Policies]** (ポリシーをアタッチ) を選択して Amazon S3 の許可を追加します。
1. **[Create policy]** (ポリシーを作成) を選択します。
1. [`JSON`] タブを選択します。
1. 次のポリシーステートメントを追加します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListBucket"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::bucket_name/*"
}
]
}
```
------
1. **[Next: Tags]** (次へ: タグ) を選択します。
1. **[Policy name]** (ポリシー名) を入力します。
1. [**Create policy**] (ポリシーの作成) を選択します。
1. Amazon SNS の許可を追加するには、Amazon S3 の許可を追加する場合と同じ手順を繰り返します。ポリシーステートメントについては、以下をアタッチします。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"sns:Publish"
],
"Effect": "Allow",
"Resource": "arn:aws:sns:us-east-1:111122223333:SNS_Topic"
}
]
}
```
------
1. **推論データ (機械学習モデル、サンプルデータなど) を **Amazon S3** にアップロードする。**
1. **構築済みの Docker 推論イメージを選択するか、独自の推論 Docker イメージを作成する。**
SageMaker AI は、Apache MXNet、TensorFlow、PyTorch、Chainer など、いくつかの最も一般的な機械学習フレームワーク用に、組み込みアルゴリズムおよび構築済みの Docker イメージのコンテナを提供しています。使用可能な SageMaker AI イメージの完全なリストについては、「[Available Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md)」を参照してください。SageMaker AI 提供のコンテナを使用する場合は、コンテナ内の環境変数を設定することで、エンドポイントのタイムアウトとペイロードサイズをデフォルトから増やすことができます。フレームワークごとに異なる環境変数を設定する方法については、非同期エンドポイントの「モデルの作成」ステップを参照してください。
既存の SageMaker AI コンテナがニーズを満たしておらず、既存の独自コンテナがない場合は、新しい Docker コンテナを作成する必要があります。Docker イメージの作成方法の詳細については、「[カスタム推論コードを持つコンテナ](your-algorithms-inference-main.md)」を参照してください。
1. **Amazon SNS トピックを作成する (オプション)。**
処理を完了したリクエストに関する通知を送信する Amazon Simple Notification Service (Amazon SNS) トピックを作成します。Amazon SNS は、メッセージング指向のアプリケーション向け通知サービスです。HTTP、Amazon SQS、メールなどのトランスポートプロトコルを選択することにより、複数のサブスクライバーがタイムクリティカルなメッセージの「プッシュ」通知を要求および受信します。Amazon SNS トピックは、`EndpointConfig` API を使用して `AsyncInferenceConfig` を指定する際、`EndpointConfig` オブジェクトを作成するときに指定できます。
手順に従って、Amazon SNS トピックを作成してサブスクライブします。
1. Amazon SNS コンソールを使用してトピックを作成します。手順については、*Amazon Simple Notification Service* 開発者ガイドの「[Amazon SNS トピックを作成する](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html)」を参照してください。**
1. トピックを受信します。手順については、*Amazon Simple Notification Service* 開発者ガイドの「[Amazon SNS トピックをサブスクライブする](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html)」を参照してください。**
1. トピックのサブスクリプションの確認を求めるメールを受信したら、サブスクリプションを確認します。
1. その Amazon リソースネーム (ARN) をメモします。作成した Amazon SNS トピックは、 AWS アカウントの別のリソースであり、一意の ARN があります。ARN の形式は次のとおりです。
```
arn:aws:sns:aws-region:account-id:topic-name
```
Amazon SNS の詳細については、「[Amazon SNS 開発者ガイド](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)」を参照してください。
# 非同期推論エンドポイントを作成する方法
SageMaker AI ホスティングサービスを使用してエンドポイントを作成する場合と同じ方法で非同期エンドポイントを作成します。
+ `CreateModel` を使用して SageMaker AI でモデルを作成する。
+ `CreateEndpointConfig` を使用してエンドポイント設定を作成する。
+ `CreateEndpoint` を使用して HTTPS エンドポイントを作成する。
エンドポイントを作成するには、まず、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) を使用してモデルアーティファクトと Docker レジストリパス (イメージ) をポイントする、モデルを作成します。次に、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) を使用して設定を作成します。この設定では、`CreateModel` API を使用して作成された 1 つ以上のデプロイするモデルと、SageMaker AI でプロビジョンするリソースを指定します。リクエストで指定したエンドポイント設定を使用して [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) でエンドポイントを作成します。非同期エンドポイントは、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API を使用して更新できます。`InvokeEndpointAsync` を使って、エンドポイント ホストされているモデルとの間で推論リクエストを送受信します。エンドポイントは [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) API を使用して削除できます。
使用可能な SageMaker イメージの完全なリストについては、「[使用可能な Deep Learning Containers イメージ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md)」を参照してください。Docker イメージの作成方法の詳細については、「[カスタム推論コードを持つコンテナ](your-algorithms-inference-main.md)」を参照してください。
**Topics**
+ [モデルを作成する](async-inference-create-endpoint-create-model.md)
+ [エンドポイント設定を作成する](async-inference-create-endpoint-create-endpoint-config.md)
+ [エンドポイントの作成](async-inference-create-endpoint-create-endpoint.md)
# モデルを作成する
次の例は、 AWS SDK for Python (Boto3)を使用してモデルを作成する方法を示しています。最初の数行では、以下を定義します。
+ `sagemaker_client`: AWS サービスへのリクエストの送受信を容易にする低レベルの SageMaker AI クライアントオブジェクト。
+ `sagemaker_role`: SageMaker AI IAM ロールの Amazon リソースネーム (ARN) を持つ文字列変数。
+ `aws_region`: AWS リージョンの名前を持つ文字列変数。
```
import boto3
# Specify your AWS Region
aws_region=''
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# Role to give SageMaker permission to access AWS services.
sagemaker_role= "arn:aws:iam:::role/*"
```
次に、Amazon S3 に保存されているトレーニング済みモデルの場所を指定します。この例では、`demo-xgboost-model.tar.gz` という名前のトレーニング済み XGBoost モデルを使用します。完全な Amazon S3 URI は文字列変数 `model_url` に保存されています。
```
#Create a variable w/ the model S3 URI
s3_bucket = '' # Provide the name of your S3 bucket
bucket_prefix='saved_models'
model_s3_key = f"{bucket_prefix}/demo-xgboost-model.tar.gz"
#Specify S3 bucket w/ model
model_url = f"s3://{s3_bucket}/{model_s3_key}"
```
プライマリコンテナを指定します。プライマリコンテナについては、推論コードを含む Docker イメージ、アーティファクト (以前のトレーニングから)、予測のためにモデルをデプロイするときに推論コードが使うカスタム環境マップを指定します。
この例では、XGBoost 組み込みアルゴリズムコンテナイメージを指定します。
```
from sagemaker import image_uris
# Specify an AWS container image.
container = image_uris.retrieve(region=aws_region, framework='xgboost', version='0.90-1')
```
`CreateModel` を使用して Amazon SageMaker AI でモデルを作成します。次を指定します:
+ `ModelName`: モデルの名前 (この例では、`model_name` という文字列変数として保存されています)。
+ `ExecutionRoleArn`: Amazon SageMaker AI が機械学習コンピューティングインスタンスへのデプロイまたはバッチ変換ジョブのためにモデルアーティファクトや Docker イメージにアクセスするのに使用できる IAM ロールの Amazon リソースネーム (ARN)。
+ `PrimaryContainer`: 推論コード、関連アーティファクト、予測のためにモデルがデプロイされるときに推論コードが使用するカスタム環境マップを含むプライマリ Docker イメージの場所。
```
model_name = ''
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': container,
'ModelDataUrl': model_url,
})
```
API パラメータの完全なリストについては、SageMaker API リファレンスガイドの [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) の説明を参照してください。
SageMaker AI 提供のコンテナを使用している場合は、このステップで環境変数を設定することで、モデルサーバーのタイムアウトとペイロードサイズをデフォルト値から、フレームワークがサポートする最大値まで増やすことができます。これらの変数を明示的に設定しないと、非同期推論がサポートする最大タイムアウトサイズとペイロードサイズを利用できない場合があります。次の例では、TorchServe をベースにした PyTorch 推論コンテナの環境変数を設定する方法を示しています。
```
model_name = ''
#Create model
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
'Image': container,
'ModelDataUrl': model_url,
'Environment': {
'TS_MAX_REQUEST_SIZE': '100000000',
'TS_MAX_RESPONSE_SIZE': '100000000',
'TS_DEFAULT_RESPONSE_TIMEOUT': '1000'
},
})
```
エンドポイントの作成が完了したら、`inference.py` スクリプトから環境変数を出力して、環境変数が正しく設定されているかどうかをテストする必要があります。次の表は、デフォルト値を変更するために設定できる複数のフレームワークの環境変数の一覧です。
| フレームワーク | 環境変数 |
| --- | --- |
| PyTorch 1.8 (TorchServe に基づく) | 'TS\$1MAX\$1REQUEST\$1SIZE': '100000000' 'TS\$1MAX\$1RESPONSE\$1SIZE': '100000000' 'TS\$1DEFAULT\$1RESPONSE\$1TIMEOUT': '1000' |
| PyTorch 1.4 (MMS に基づく) | 'MMS\$1MAX\$1REQUEST\$1SIZE': '1000000000' 'MMS\$1MAX\$1RESPONSE\$1SIZE': '1000000000' 'MMS\$1DEFAULT\$1RESPONSE\$1TIMEOUT': '900' |
| HuggingFace 推論コンテナ (MMS に基づく) | 'MMS\$1MAX\$1REQUEST\$1SIZE': '2000000000' 'MMS\$1MAX\$1RESPONSE\$1SIZE': '2000000000' 'MMS\$1DEFAULT\$1RESPONSE\$1TIMEOUT': '900' |
# エンドポイント設定を作成する
モデルを作成したら、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) を使用してエンドポイント設定を作成します。Amazon SageMaker AI ホスティングサービスはこの設定を使用してモデルをデプロイします。この設定では、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) を使用して作成された 1 つ以上のモデルを特定して、Amazon SageMaker AI がプロビジョンするリソースをデプロイします。`AsyncInferenceConfig` オブジェクトを指定し、`OutputConfig` に対する出力 Amazon S3 ロケーションを指定します。オプションで、予測結果に関する通知を送信する [Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html) トピックを指定できます。Amazon SNS トピックの詳細については、「[Amazon SNS を設定する](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html)」を参照してください。
次の例では、 AWS SDK for Python (Boto3)を使用してエンドポイント設定を作成する方法を示します。
```
import datetime
from time import gmtime, strftime
# Create an endpoint config name. Here we create one based on the date
# so it we can search endpoints based on creation time.
endpoint_config_name = f"XGBoostEndpointConfig-{strftime('%Y-%m-%d-%H-%M-%S', gmtime())}"
# The name of the model that you want to host. This is the name that you specified when creating the model.
model_name=''
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name, # You will specify this name in a CreateEndpoint request.
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": model_name,
"InstanceType": "ml.m5.xlarge", # Specify the compute instance type.
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
],
AsyncInferenceConfig={
"OutputConfig": {
# Location to upload response outputs when no location is provided in the request.
"S3OutputPath": f"s3://{s3_bucket}/{bucket_prefix}/output"
# (Optional) specify Amazon SNS topics
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:aws-region:account-id:topic-name",
"ErrorTopic": "arn:aws:sns:aws-region:account-id:topic-name",
}
},
"ClientConfig": {
# (Optional) Specify the max number of inflight invocations per instance
# If no value is provided, Amazon SageMaker will choose an optimal value for you
"MaxConcurrentInvocationsPerInstance": 4
}
}
)
print(f"Created EndpointConfig: {create_endpoint_config_response['EndpointConfigArn']}")
```
前述の例では、次のキーを `AsyncInferenceConfig` フィールドの `OutputConfig` に指定します。
+ `S3OutputPath`: リクエストで場所が指定されていない場合に、レスポンスの出力をアップロードする場所。
+ `NotificationConfig`: (オプション) 推論リクエストが正常に終了した場合 (`SuccessTopic`) または失敗した場合 (`ErrorTopic`) に通知を投稿する SNS トピック。
`AsyncInferenceConfig` フィールドの `ClientConfig` に次のオプションの引数を指定することもできます。
+ `MaxConcurrentInvocationsPerInstance`: (オプション) SageMaker AI クライアントがモデルコンテナに送信する同時リクエストの最大数。
# エンドポイントの作成
モデルとエンドポイントの設定が完了したら、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) API を使用してエンドポイントを作成します。エンドポイント名は、 AWS アカウントの AWS リージョン内で一意である必要があります。
次が、リクエストで指定されたエンドポイント設定を使用してエンドポイントを作成します。Amazon SageMaker AI は、エンドポイントを使用してリソースをプロビジョンし、モデルをデプロイします。
```
# The name of the endpoint.The name must be unique within an AWS Region in your AWS account.
endpoint_name = ''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
create_endpoint_response = sagemaker_client.create_endpoint(
EndpointName=endpoint_name,
EndpointConfigName=endpoint_config_name)
```
`CreateEndpoint` API を呼び出すと、Amazon SageMaker 非同期推論は、Amazon SNS トピックを設定したことをチェックするテスト通知を送信します。Amazon SageMaker 非同期推論は、`UpdateEndpoint` および `UpdateEndpointWeightsAndCapacities` への呼び出し後にテスト通知も送信します。これにより、SageMaker AI は必要な許可があることをチェックします。通知は無視できます。テスト通知は次の形式です。
```
{
"eventVersion":"1.0",
"eventSource":"aws:sagemaker",
"eventName":"TestNotification"
}
```
# 非同期エンドポイントを呼び出す
`InvokeEndpointAsync` を使用して非同期エンドポイントでホストされているモデルから推論を取得します。
**注記**
まだ行っていない場合、推論データ (機械学習モデル、サンプルデータなど) を Amazon S3 にアップロードします。
リクエストに次のフィールドを指定してください。
+ `InputLocation` には、推論データの場所を指定します。
+ `EndpointName` には、エンドポイントの名前を指定します。
+ (オプション) `InvocationTimeoutSeconds` では、リクエストの最大タイムアウトを設定できます。この値は、1 回のリクエスト当たり最大 3600 秒 (1 時間) に設定できます。リクエストにこのフィールドを指定しない場合、デフォルトではリクエストは 15 分でタイムアウトします。
```
# Create a low-level client representing Amazon SageMaker Runtime
sagemaker_runtime = boto3.client("sagemaker-runtime", region_name=)
# Specify the location of the input. Here, a single SVM sample
input_location = "s3://bucket-name/test_point_0.libsvm"
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name=''
# After you deploy a model into production using SageMaker AI hosting
# services, your client applications use this API to get inferences
# from the model hosted at the specified endpoint.
response = sagemaker_runtime.invoke_endpoint_async(
EndpointName=endpoint_name,
InputLocation=input_location,
InvocationTimeoutSeconds=3600)
```
JSON 文字列としてレスポンスを受け取ります。これには、リクエスト ID と、処理後に API コールに対するレスポンスを受ける Amazon S3 バケット名が含まれます。
# 非同期エンドポイントを更新する
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API を使用して非同期エンドポイントを更新します。エンドポイントを更新すると、SageMaker AI はまず、前のエンドポイント設定でプロビジョニングされたリソースを削除する前に、指定した新しいエンドポイント設定をプロビジョニングして切り替えます。活動中のエンドポイントを持っている、あるいはそのエンドポイントで `UpdateEndpoint` または `CreateEndpoint` オペレーションが実行されている間は、`EndpointConfig` を削除しないでください。
```
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name=''
# The name of the endpoint configuration associated with this endpoint.
endpoint_config_name=''
sagemaker_client.update_endpoint(
EndpointConfigName=endpoint_config_name,
EndpointName=endpoint_name
)
```
Amazon SageMaker AI がリクエストを受信すると、エンドポイントのステータスは **[更新中]** になります。非同期エンドポイントが更新されると、ステータスは **[InService]** (実行中) になります。エンドポイントのステータスをチェックするには、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) API を使用します。エンドポイントの更新時に指定できるパラメータの完全なリストについては、「[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API」を参照してください。
# 非同期エンドポイントを削除する
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteEndpoint.html) API を使用して、SageMaker AI でホストされているエンドポイントを削除する場合と同様の方法で非同期エンドポイントを削除します。削除する非同期エンドポイントの名前を指定します。エンドポイントを削除すると、SageMaker AI は、エンドポイントの作成時にデプロイされたすべてのリソースを解放します。モデルを削除しても、モデルアーティファクト、推論コード、モデル作成時に指定した IAM ロールは削除されません。
SageMaker AI モデルを [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteModel.html) API または SageMaker AI コンソールを使用して削除します。
------
#### [ Boto3 ]
```
import boto3
# Create a low-level SageMaker service client.
sagemaker_client = boto3.client('sagemaker', region_name=)
sagemaker_client.delete_endpoint(EndpointName='')
```
------
#### [ SageMaker AI console ]
1. SageMaker AI コンソール ([https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)) に移動します。
1. **[Inference]** (推論) ドロップダウンリストを展開します。
1. [**Endpoints**] を選択します。
1. **[Search endpoints]** (エンドポイントを検索) 検索バーでエンドポイントを検索します。
1. エンドポイントを選択します。
1. **[削除]** を選択します。
------
非同期エンドポイントの削除に加えて、Amazon ECR リポジトリ (カスタム推論イメージを作成してした場合)、SageMaker AI モデル、非同期エンドポイント設定自体など、エンドポイントの作成に使用された他のリソースを消去することもできます。
# 非同期エンドポイントからメトリクスを追跡するためのアラームとログ
Amazon CloudWatch を使用して SageMaker AI をモニタリングすることで、raw データを収集し、リアルタイムに近い読み取り可能なメトリクスに加工できます。Amazon CloudWatch を使用し、履歴情報にアクセスして、ウェブアプリケーションやサービスのパフォーマンスをより的確に把握できます。Amazon CloudWatch の詳細については、「[Amazon CloudWatch とは](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html)」を参照してください。
## CloudWatch によるモニタリング
次のメトリクスは、非同期エンドポイントに対するメトリクスの網羅的なリストで、`AWS/SageMaker` 名前空間にあります。エンドポイントが非同期推論のために有効化されている場合、以下にリストされていないメトリクスは発行されません。該当するメトリクスは以下の通りです (ただし、以下に限定されません)。
+ OverheadLatency
+ Invocations
+ InvocationsPerInstance
### 共通のエンドポイントメトリクス
これらのメトリクスは、現在リアルタイムエンドポイントについて発行されるメトリクスと同じです。Amazon CloudWatch の他のメトリクスについては、「[Monitor SageMaker AI with Amazon CloudWatch](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html)」を参照してください。
| メトリクス名 | 説明 | 単位/統計 |
| --- | --- | --- |
| `Invocation4XXErrors` | 4xx HTTP レスポンスコードを返したモデルの リクエスト数。各 4xx レスポンスについて、1 が送信されます。それ以外の場合は 0 が送信されます。 | 単位: なし有効な統計: 合計、平均 |
| `Invocation5XXErrors` | モデルが 5xx HTTP レスポンスコードを返した InvokeEndpoint リクエストの数。各 5xx レスポンスについて、1 が送信されます。それ以外の場合は 0 が送信されます。 | 単位: なし有効な統計: 合計、平均 |
| `ModelLatency` | SageMaker AI から見た、モデルが応答するのにかかる時間間隔。この間隔には、リクエストを送信し、モデルのコンテナからレスポンスを取得するのにかかるローカル通信時間と、コンテナ内で推論を完了するのにかかる時間が含まれます。 | 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
### 非同期推論エンドポイントメトリクス
これらのメトリクスが、非同期推論が有効なエンドポイントについて発行されます。次のメトリクスは、`EndpointName` ディメンションで発行されます。
| メトリクス名 | 説明 | 単位/統計 |
| --- | --- | --- |
| `ApproximateBacklogSize` | 現在処理中またはまだ処理されていないエンドポイントに対するキュー内の項目の数。 | 単位: カウント 有効な統計: Average、Max、Min |
| `ApproximateBacklogSizePerInstance` | キュー内の項目数をエンドポイントの背後にあるインスタンス数で割った値。このメトリクスは主に、非同期対応エンドポイントに対するアプリケーションのオートスケーリングの設定に使用されます。 | 単位: カウント有効な統計: Average、Max、Min |
| `ApproximateAgeOfOldestRequest` | キュー内の最も古いリクエストの経過時間。 | 単位: 秒有効な統計: Average、Max、Min |
| `HasBacklogWithoutCapacity` | このメトリクスの値は、キューにリクエストがあるが、エンドポイントの後ろにゼロインスタンスがあるとき、`1` になります。それ以外の場合は、値は `0` です。このメトリクスを使用して、キュー内の新しいリクエストを受信し、エンドポイントをゼロインスタンスからオートスケーリングできます。 | 単位: カウント有効な統計: 平均 |
次のメトリクスは、`EndpointName` と `VariantName` ディメンションで発行されます。
| メトリクス名 | 説明 | 単位/統計 |
| --- | --- | --- |
| `RequestDownloadFailures` | Amazon S3 からのリクエストのダウンロードの問題により推論障害が発生した場合。 | 単位: カウント有効な統計: Sum |
| `ResponseUploadFailures` | Amazon S3 へのレスポンスのアップロードの問題により推論障害が発生した場合。 | 単位: カウント有効な統計: Sum |
| `NotificationFailures` | 通知の発行で問題が発生した場合。 | 単位: カウント有効な統計: Sum |
| `RequestDownloadLatency` | リクエストペイロードのダウンロードの合計時間。 | 単位: マイクロ秒有効な統計: Average、Sum、Min、Max、Sample Count |
| `ResponseUploadLatency` | レスポンスペイロードのアップロードの合計時間。 | 単位: マイクロ秒 有効な統計: Average、Sum、Min、Max、Sample Count |
| `ExpiredRequests` | 指定されたリクエスト TTL に到達したために失敗したキュー内のリクエストの数。 | 単位: カウント有効な統計: Sum |
| `InvocationFailures` | 何らかの理由で呼び出しが失敗した場合。 | 単位: カウント有効な統計: Sum |
| `InvocationsProcesssed` | エンドポイントによって処理された非同期呼び出しの数。 | 単位: カウント有効な統計: Sum |
| `TimeInBacklog` | リクエストが処理される前にキューに入れられた合計時間。これには、実際の処理時間 (ダウンロード時間、アップロード時間、モデルのレイテンシーなど) は含まれません。 | 単位: ミリ秒有効な統計: Average、Sum、Min、Max、Sample Count |
| `TotalProcessingTime` | SageMaker AI が推論リクエストを受け取ってから、リクエストの処理が終了するまでの時間。これには、バックログの時間、レスポンス通知をアップロードして送信する時間 (ある場合) が含まれます。 | 単位: ミリ秒有効な統計: Average、Sum、Min、Max、Sample Count |
Amazon SageMaker 非同期推論には、ホストレベルのメトリクスも含まれます。ホストレベルのメトリクスの詳細については、「[SageMaker AI のジョブとエンドポイントのメトリクス](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-jobs)」を参照してください。
## ログ
お使いのアカウントの Amazon CloudWatch に発行される[モデルのコンテナログ](https://docs.aws.amazon.com/sagemaker/latest/dg/logging-cloudwatch.html)に加えて、推論リクエストをトレースおよびデバッグするための新しいプラットフォームログも取得します。
新しいログはエンドポイントロググループ下で発行されます。
```
/aws/sagemaker/Endpoints/[EndpointName]
```
ログストリーム名は次の値で構成されます。
```
[production-variant-name]/[instance-id]/data-log.
```
ログの行にはリクエストの推論 ID が含まれているため、エラーを特定のリクエストに簡単にマッピングできます。
# 予測結果をチェックする
非同期エンドポイントからの予測結果をチェックする方法は複数あります。一部のオプションは次のとおりです。
1. Amazon SNS トピック。
1. Amazon S3 バケット内の出力をチェックします。
## Amazon SNS トピック
Amazon SNS は、メッセージング指向のアプリケーション向け通知サービスです。HTTP、Amazon SQS、メールなどのトランスポートプロトコルを選択することにより、複数のサブスクライバーがタイムクリティカルなメッセージの「プッシュ」通知を要求および受信します。[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html) を使用してエンドポイントを作成し、Amazon SNS トピックを指定すると、Amazon SageMaker 非同期推論により通知が投稿されます。
**注記**
Amazon SNS 通知を受信するには、IAM ロールに `sns:Publish` の許可が必要です。非同期推論を使用するために満たす必要がある要件については、「[の前提条件を満たす](async-inference-create-endpoint-prerequisites.md)」を参照してください。
Amazon SNS を使って非同期エンドポイントからの予測結果をチェックするには、まずトピックを作成してそのトピックをサブスクライブし、トピックのサブスクリプションを確認してから、そのトピックの Amazon リソースネーム (ARN) を把握しておく必要があります。Amazon SNS トピックの Amazon ARN を作成、サブスクライブ、発見する方法の詳細については、「[Amazon SNS を設定する](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html)」を参照してください。
`CreateEndpointConfig` を使用してエンドポイント設定を作成する際に、`AsyncInferenceConfig` フィールドに Amazon SNS トピックの ARN を指定します。Amazon SNS `ErrorTopic` と `SuccessTopic` の両方を指定できます。
```
import boto3
sagemaker_client = boto3.client('sagemaker', region_name=)
sagemaker_client.create_endpoint_config(
EndpointConfigName=, # You specify this name in a CreateEndpoint request.
# List of ProductionVariant objects, one for each model that you want to host at this endpoint.
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": "model_name",
"InstanceType": "ml.m5.xlarge", # Specify the compute instance type.
"InitialInstanceCount": 1 # Number of instances to launch initially.
}
],
AsyncInferenceConfig={
"OutputConfig": {
# Location to upload response outputs when no location is provided in the request.
"S3OutputPath": "s3:///"
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:aws-region:account-id:topic-name",
"ErrorTopic": "arn:aws:sns:aws-region:account-id:topic-name",
}
}
}
)
```
エンドポイントを作成して呼び出すと、Amazon SNS トピックから通知を受け取ります。例えば、トピックから E メール通知を受信するようにサブスクライブした場合、エンドポイントを呼び出すたびに E メール通知を受け取ります。次の例は、正常な呼び出し E メール通知の JSON コンテンツを示しています。
```
{
"awsRegion":"us-east-1",
"eventTime":"2022-01-25T22:46:00.608Z",
"receivedTime":"2022-01-25T22:46:00.455Z",
"invocationStatus":"Completed",
"requestParameters":{
"contentType":"text/csv",
"endpointName":"",
"inputLocation":"s3:////input-data.csv"
},
"responseParameters":{
"contentType":"text/csv; charset=utf-8",
"outputLocation":"s3:////prediction.out"
},
"inferenceId":"11111111-2222-3333-4444-555555555555",
"eventVersion":"1.0",
"eventSource":"aws:sagemaker",
"eventName":"InferenceResult"
}
```
## S3 バケットをチェックする
`InvokeEndpointAsync` を使用してエンドポイントを呼び出すと、レスポンスオブジェクトが返されます。レスポンスオブジェクトを使用して、出力が保存されている Amazon S3 URI を取得できます。出力場所がわかることで、SageMaker Python SDK SageMaker AI セッションクラスを使って、出力をプログラムによりチェックできます。
次の例では、`InvokeEndpointAsync` の出力ディクショナリを response という名前の変数として保存します。レスポンス変数を使用して、Amazon S3 出力 URI を取得し、`output_location` という文字列変数として保存します。
```
import uuid
import boto3
sagemaker_runtime = boto3.client("sagemaker-runtime", region_name=)
# Specify the S3 URI of the input. Here, a single SVM sample
input_location = "s3://bucket-name/test_point_0.libsvm"
response = sagemaker_runtime.invoke_endpoint_async(
EndpointName='',
InputLocation=input_location,
InferenceId=str(uuid.uuid4()),
ContentType="text/libsvm" #Specify the content type of your data
)
output_location = response['OutputLocation']
print(f"OutputLocation: {output_location}")
```
サポートされるコンテンツタイプについては、「[推論の共通データ形式](cdf-inference.md)」を参照してください。
Amazon S3 出力場所を使って、[SageMaker Python SDK SageMaker AI セッションクラス](https://sagemaker.readthedocs.io/en/stable/api/utility/session.html?highlight=session)を使用して Amazon S3 ファイルを読み取ります。次のコード例は、Amazon S3 出力場所からファイルの読み取りを繰り返し試みる関数 (`get_ouput`) を作成する方法を示しています。
```
import sagemaker
import urllib, time
from botocore.exceptions import ClientError
sagemaker_session = sagemaker.session.Session()
def get_output(output_location):
output_url = urllib.parse.urlparse(output_location)
bucket = output_url.netloc
key = output_url.path[1:]
while True:
try:
return sagemaker_session.read_s3_file(
bucket=output_url.netloc,
key_prefix=output_url.path[1:])
except ClientError as e:
if e.response['Error']['Code'] == 'NoSuchKey':
print("waiting for output...")
time.sleep(2)
continue
raise
output = get_output(output_location)
print(f"Output: {output}")
```
# 非同期エンドポイントをオートスケールする
Amazon SageMaker AI では、非同期エンドポイントの自動的なスケーリング (オートスケーリング) がサポートされています。自動スケーリングは、ワークロードの変動に応じて、モデルにプロビジョニングされたインスタンスの数を動的に調整します。Amazon SageMaker AI がサポートしている他のホストモデルとは異なり、非同期推論を使用すると、非同期エンドポイントのインスタンスをゼロにスケールダウンすることもできます。インスタンスがゼロの場合に受信されるリクエストは、エンドポイントがスケールアップされると処理のためにキューに入れられます。
非同期エンドポイントをオートスケールするには、少なくとも以下を行う必要があります。
+ デプロイされたモデル (本番稼働用バリアント) を登録する。
+ スケーリングポリシーを定義する。
+ オートスケーリングポリシーを適用する。
オートスケールを使用するには、SageMaker AI のエンドポイントにモデルをデプロイしておく必要があります。デプロイされたモデルは、[本番稼動用バリアント](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html)と呼ばれます。エンドポイントへのモデルのデプロイの詳細については、「[Deploy the Model to SageMaker Hosting Services](https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-model-deployment.html#ex1-deploy-model)」を参照してください。スケーリングポリシーのメトリクスとターゲット値を指定するには、スケーリングポリシーを設定します。スケーリングポリシーを定義する方法の詳細については、「[スケーリングポリシーを定義する](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-add-code-define.html)」を参照してください。モデルを登録してスケーリングポリシーを定義した後に、そのスケーリングポリシーを登録されたモデルに適用します。スケーリングポリシーを適用する方法の詳細については、「[スケーリングポリシーを適用する](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-add-code-apply.html)」を参照してください。
エンドポイントがゼロにスケールダウンされてからリクエストを受信した際にエンドポイントをスケールアップする、オプションの追加のスケーリングポリシーを定義する方法の詳細については、「[オプション: 新しいリクエストに合わせてゼロからスケールアップするスケーリングポリシーを定義します。](#async-inference-autoscale-scale-up)」を参照してください。このオプションポリシーを指定しない場合、バックログリクエストの数がターゲットのトラッキング値を超えた後にのみ、エンドポイントはゼロからのスケールアップを開始します。
オートスケーリングに関わるその他の前提条件およびコンポーネントの詳細については、SageMaker AI オートスケーリングに関するドキュメントの「[前提条件](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling-prerequisites.html)」セクションを参照してください。
**注記**
同じ自動スケーリンググループに複数のスケーリングポリシーをアタッチすると、スケーリングが競合する可能性があります。競合が発生すると、Amazon EC2 Auto Scaling はスケールアウトとスケールインの両方で最大のキャパシティーをプロビジョニングするポリシーを選択します。この動作の詳細については、Amazon EC2 Auto Scaling ドキュメントの「[複数の動的スケーリングポリシー](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-scale-based-on-demand.html#multiple-scaling-policy-resolution)」を参照してください。
## スケーリングポリシーを定義する
スケーリングポリシーのメトリクスとターゲット値を指定するには、ターゲット追跡スケーリングポリシーを設定します。スケーリングポリシーを JSON ブロックとしてテキストファイルに定義します。このテキストファイルは、AWS CLI または アプリケーションの Auto Scaling API を呼び出す際に使用します。ポリシー設定構文の詳細については、Application Auto Scaling API リファレンスの「[https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html](https://docs.aws.amazon.com/autoscaling/application/APIReference/API_TargetTrackingScalingPolicyConfiguration.html)」を参照してください。
非同期エンドポイントについて、SageMaker AI では、バリアントに対するターゲット追跡スケーリングのポリシー設定を作成することを強くお勧めします。この設定例では、`ApproximateBacklogSizePerInstance` というカスタムメトリクス `CustomizedMetricSpecification` を使用します。
```
TargetTrackingScalingPolicyConfiguration={
'TargetValue': 5.0, # The target value for the metric. Here the metric is: ApproximateBacklogSizePerInstance
'CustomizedMetricSpecification': {
'MetricName': 'ApproximateBacklogSizePerInstance',
'Namespace': 'AWS/SageMaker',
'Dimensions': [
{'Name': 'EndpointName', 'Value': }
],
'Statistic': 'Average',
}
}
```
## ゼロにスケールするスケーリングポリシーを定義する
以下に、AWS SDK for Python (Boto3) を使って、アプリケーションオートスケーリングを備えるエンドポイントバリアントを定義および登録する方法を示します。Boto3 でアプリケーションオートスケーリングを行う低レベルのクライアントオブジェクトを定義した後、[https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target) メソッドを使用して本番稼働用バリアントを登録します。処理するリクエストがない場合、非同期推論では 0 にオートスケールできるため、`MinCapacity` を 0 に設定します。
```
# Common class representing application autoscaling for SageMaker
client = boto3.client('application-autoscaling')
# This is the format in which application autoscaling references the endpoint
resource_id='endpoint/' + + '/variant/' + <'variant1'>
# Define and register your endpoint variant
response = client.register_scalable_target(
ServiceNamespace='sagemaker',
ResourceId=resource_id,
ScalableDimension='sagemaker:variant:DesiredInstanceCount', # The number of EC2 instances for your Amazon SageMaker model endpoint variant.
MinCapacity=0,
MaxCapacity=5
)
```
アプリケーションオートスケーリング API の詳細については、「[アプリケーションスケーリング Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/application-autoscaling.html#ApplicationAutoScaling.Client.register_scalable_target)」のドキュメントを参照してください。
## オプション: 新しいリクエストに合わせてゼロからスケールアップするスケーリングポリシーを定義します。
散発的なリクエストやリクエスト数が少ない期間があるユースケースがあるかもしれません。この期間中にエンドポイントのインスタンスがゼロインスタンスにスケールダウンされた場合、キュー内のリクエスト数がスケーリングポリシーで指定された目標を超えるまで、エンドポイントは再びスケールアップされません。その結果、キュー内のリクエストの待ち時間が長くなる可能性があります。次のセクションでは、キューで新しいリクエストを受け取った後に、エンドポイントをゼロインスタンスからスケールアップする追加のスケーリングポリシーを作成する方法を示します。エンドポイントは、キューのサイズが目標を超えるのを待つ代わりに、より迅速に新しいリクエストに応答できるようになります。
インスタンスをゼロからスケールアップするエンドポイントのスケーリングポリシーを作成するには、次の操作を行います。
1. 必要な動作を定義するスケーリングポリシーを作成します。これは、インスタンスがゼロでもキューにリクエストがある場合にエンドポイントをスケールアップします。以下は、AWS SDK for Python (Boto3) を使用して `HasBacklogWithoutCapacity-ScalingPolicy` というスケーリングポリシーを定義する方法を示しています。キューがゼロより大きく、エンドポイントの現在のインスタンス数もゼロの場合、ポリシーはエンドポイントをスケールアップします。それ以外の場合、このポリシーはエンドポイント向けにスケーリングに影響しません。
```
response = client.put_scaling_policy(
PolicyName="HasBacklogWithoutCapacity-ScalingPolicy",
ServiceNamespace="sagemaker", # The namespace of the service that provides the resource.
ResourceId=resource_id, # Endpoint name
ScalableDimension="sagemaker:variant:DesiredInstanceCount", # SageMaker supports only Instance Count
PolicyType="StepScaling", # 'StepScaling' or 'TargetTrackingScaling'
StepScalingPolicyConfiguration={
"AdjustmentType": "ChangeInCapacity", # Specifies whether the ScalingAdjustment value in the StepAdjustment property is an absolute number or a percentage of the current capacity.
"MetricAggregationType": "Average", # The aggregation type for the CloudWatch metrics.
"Cooldown": 300, # The amount of time, in seconds, to wait for a previous scaling activity to take effect.
"StepAdjustments": # A set of adjustments that enable you to scale based on the size of the alarm breach.
[
{
"MetricIntervalLowerBound": 0,
"ScalingAdjustment": 1
}
]
},
)
```
1. カスタムトリクス `HasBacklogWithoutCapacity` を使用して CloudWatch アラームを作成します。トリガーされると、アラームは以前に定義したスケーリングポリシーを開始します。`HasBacklogWithoutCapacity` メトリクスの詳細については、「[非同期推論エンドポイントメトリクス](async-inference-monitor.md#async-inference-monitor-cloudwatch-async)」を参照してください。
```
response = cw_client.put_metric_alarm(
AlarmName=step_scaling_policy_alarm_name,
MetricName='HasBacklogWithoutCapacity',
Namespace='AWS/SageMaker',
Statistic='Average',
EvaluationPeriods= 2,
DatapointsToAlarm= 2,
Threshold= 1,
ComparisonOperator='GreaterThanOrEqualToThreshold',
TreatMissingData='missing',
Dimensions=[
{ 'Name':'EndpointName', 'Value':endpoint_name },
],
Period= 60,
AlarmActions=[step_scaling_policy_arn]
)
```
これで、キューに保留中のリクエストがあるたびに、エンドポイントをゼロインスタンスからスケールアップするスケーリングポリシーと CloudWatch アラームが作成されます。
# トラブルシューティング
以下のよくある質問は、Amazon SageMaker 非同期推論エンドポイントの問題をトラブルシューティングするのに役立ちます。
## Q: 自動スケーリングを有効にしました。任意の時点でエンドポイントの背後にあるインスタンス数を調べるにはどうすればよいですか?
以下の方法を使用して、エンドポイントの背後にあるインスタンス数を確認できます。
+ SageMaker AI [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) API を使用すると、任意の時点におけるエンドポイントの背後にあるインスタンスの数を記述できます。
+ インスタンス数は、Amazon CloudWatch メトリクスを表示することで取得できます。`CPUUtilization` や `MemoryUtilization` などの[エンドポイントインスタンスのメトリクス](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-cloudwatch.html#cloudwatch-metrics-jobs)を表示し、1 分間のサンプル数統計を確認します。この数は、アクティブなインスタンスの数と同じである必要があります。次のスクリーンショットは、CloudWatch コンソールでグラフ化された `CPUUtilization` メトリクスを示しています。**統計**は `Sample count` に設定され、**期間**は `1 minute` に設定され、結果の数は 5 です。
![\[エンドポイントのアクティブなインスタンス数のグラフが表示された CloudWatch コンソール。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/cloudwatch-sample-count.png)
## Q: SageMaker AI コンテナに共通する調整可能な環境変数にはどのようなものがありますか?
以下のテーブルは、SageMaker AI コンテナの一般的な調整可能な環境変数をフレームワークタイプ別にまとめたものです。
**TensorFlow**
| 環境変数 | 説明 |
| --- | --- |
| `SAGEMAKER_TFS_INSTANCE_COUNT` | TensorFlow ベースのモデルの場合、`tensorflow_model_server` バイナリはメモリへのモデルの読み込み、モデルグラフに対する入力の実行、出力の取得を行う操作要素です。通常、このバイナリのインスタンスは 1 つ起動され、エンドポイント内のモデルを処理します。このバイナリは内部でマルチスレッド化されており、推論リクエストに応答するために複数のスレッドを生成します。インスタンスによっては、CPU がある程度 (使用率が 30% 以上) 使用されていても、メモリが十分に活用されていない場合 (使用率が 10% 未満) は、このパラメータを増やすと役立つ場合があります。利用可能な `tensorflow_model_servers` の数を増やすと、一般的にエンドポイントのスループットが向上します。 |
| `SAGEMAKER_TFS_FRACTIONAL_GPU_MEM_MARGIN` | このパラメータは、CUDA/cuDNN やその他の GPU ライブラリを初期化するために利用可能な GPU メモリの割合を制御します。`0.2` は利用可能な GPU メモリの 20% が CUDA/cuDNN と他の GPU ライブラリを初期化するために予約され、利用可能な GPU メモリの 80% が TF プロセス全体に均等に割り当てられることを意味します。`allow_growth` オプションが有効になっていない限り、GPU メモリは事前に割り当てられます。 |
| `SAGEMAKER_TFS_INTER_OP_PARALLELISM` | これは `inter_op_parallelism_threads` 変数と結びついています。この変数は、独立したノンブロッキング操作で使用されるスレッドの数を決定します。`0` は、システムが適切な数を選択することを意味します。 |
| `SAGEMAKER_TFS_INTRA_OP_PARALLELISM` | これは `intra_op_parallelism_threads` 変数と結びついています。これにより、行列の乗算や高速化のための削減などの特定の操作に使用できるスレッド数が決まります。`0` の値は、システムが適切な数を選択することを意味します。 |
| `SAGEMAKER_GUNICORN_WORKERS` | これは Gunicorn がリクエストを処理するために生成するように要求されるワーカープロセスの数を制御します。この値を他のパラメータと組み合わせて使用すると、推論スループットを最大化するセットが導出されます。これに加えて、`SAGEMAKER_GUNICORN_WORKER_CLASS` は生成されるワーカーのタイプ (通常は `async` または `gevent`) を決定します。 |
| `SAGEMAKER_GUNICORN_WORKER_CLASS` | これは Gunicorn がリクエストを処理するために生成するように要求されるワーカープロセスの数を制御します。この値を他のパラメータと組み合わせて使用すると、推論スループットを最大化するセットが導出されます。これに加えて、`SAGEMAKER_GUNICORN_WORKER_CLASS` は生成されるワーカーのタイプ (通常は `async` または `gevent`) を決定します。 |
| `OMP_NUM_THREADS` | Python は、プロセス内でのマルチスレッドの実装に OpenMP を内部的に使用しています。通常、CPU コアの数と同じ数のスレッドが生成されます。しかし、Intel の HypeThreading などの同時マルチスレッディング (SMT) の上に実装すると、特定のプロセスが実際の CPU コア数の 2 倍のスレッドを生成して、特定のコアをオーバーサブスクライブする可能性があります。場合によっては、Python バイナリは、使用可能なプロセッサコアの最大 4 倍のスレッドを生成することがあります。そのため、ワーカースレッドを使用して使用可能なコアをオーバーサブスクライブしている場合、このパラメータの理想的な設定は `1`、または SMT がオンになっている CPU の CPU コア数の半分です。 |
| `TF_DISABLE_MKL` `TF_DISABLE_POOL_ALLOCATOR` | `TF_DISABLE_MKL` と `TF_DISABLE_POOL_ALLOCATOR` が `1` に設定されている場合、MKL をオフにすると推論が速くなる場合があります。 |
**PyTorch**
| 環境変数 | 説明 |
| --- | --- |
| `SAGEMAKER_TS_MAX_BATCH_DELAY` | これは TorchServe が受信するまで待機する最大バッチ遅延時間です。 |
| `SAGEMAKER_TS_BATCH_SIZE` | タイマーが切れる前に `batch_size` で指定された数のリクエストを受信しなかった場合、TorchServe は受信したリクエストをモデルハンドラに送ります。 |
| `SAGEMAKER_TS_MIN_WORKERS` | TorchServe がスケールダウンできるワーカーの最小数。 |
| `SAGEMAKER_TS_MAX_WORKERS` | TorchServe がスケールアップできるワーカーの最大数。 |
| `SAGEMAKER_TS_RESPONSE_TIMEOUT` | 応答がない場合に推論がタイムアウトになるまでの遅延時間。 |
| `SAGEMAKER_TS_MAX_REQUEST_SIZE` | TorchServe の最大ペイロードサイズ。 |
| `SAGEMAKER_TS_MAX_RESPONSE_SIZE` | TorchServe の最大レスポンスサイズ。 |
**マルチモデルサーバー (MMS)**
| 環境変数 | 説明 |
| --- | --- |
| `job_queue_size` | このパラメータは、推論リクエストのペイロードの種類が大きく、ペイロードのサイズが大きいため、このキューが管理されている JVM のヒープメモリ消費量が増える可能性がある場合の調整に役立ちます。JVM のヒープメモリ要件を低く抑え、Python ワーカーが実際のモデル処理により多くのメモリを割り当てられるようにすることが理想的です。JVM は、HTTP リクエストを受信してキューに入れ、Python ベースのワーカーにディスパッチして推論するためだけのものです。`job_queue_size` を増やすと、JVM のヒープメモリ消費量が増え、最終的には Python ワーカーが使用していたはずのメモリがホストから奪われる可能性があります。そのため、このパラメータを調整する際にも注意が必要です。 |
| `default_workers_per_model` | このパラメータはバックエンドモデルサービス用であり、Python が各モデルの生成スレッドを処理するベースとなるモデルサービス全体の重要なコンポーネントであるため、調整することが有益である場合があります。このコンポーネントが遅い (または適切に調整されていない) 場合、フロントエンドの調整には効果がない可能性があります。 |
## Q: コンテナが非同期推論をサポートしていることを確認する方法を教えてください。
非同期推論には、リアルタイム推論や Batch 変換と同じコンテナを使用できます。コンテナのタイムアウトとペイロードサイズの制限が、より大きなペイロードと長いタイムアウトを処理するように設定されていることを確認する必要があります。
## Q: 非同期推論にはどのような制限がありますか? 非同期推論を調整するこはできますか?
非同期推論については、以下の制限を参照してください。
+ ペイロードサイズの制限: 1 GB
+ タイムアウト制限: リクエストには最大 60 分かかります。
+ キューメッセージの TimeToLive (TTL): 6 時間
+ Amazon SQS 内に保存できるメッセージの数: 無制限。ただし、標準キューの伝送中メッセージには 120,000 件、FIFO キューには 20,000 件という制限があります。
## Q: 非同期推論の自動スケーリングにはどのようなメトリクスを定義するのが最適ですか? 複数のスケーリングポリシーを設定できますか?
一般に、非同期推論では、呼び出しまたはインスタンスに基づいてスケールアウトできます。呼び出しメトリクスについては、キュー内のまだ処理されていないアイテムの数を定義するメトリクスである `ApproximateBacklogSize` を確認することをお勧めします。このメトリクスまたは `InvocationsPerInstance` メトリクスを利用して、どの TPS が制限されているかを把握できます。インスタンスレベルでは、インスタンスタイプとその CPU/GPU 使用率を確認して、いつスケールアウトするかを定義します。1 つのインスタンスの容量が 60～70% を超えている場合は、ハードウェアが飽和状態になっていることを示す良い兆候です。
複数のスケーリングポリシーを設定することはお勧めしません。これらのポリシーは、ハードウェアレベルで競合して混乱を招き、スケールアウト時に遅延を引き起こす可能性があります。
## Q: 非同期エンドポイントがインスタンスを `Unhealthy` として終了させ、自動スケーリングからの更新リクエストが失敗するのはなぜですか?
コンテナが ping リクエストと呼び出しリクエストを同時に処理できるかどうかを確認してください。SageMaker AI の呼び出しリクエストには約 3 分かかります。この間、通常、タイムアウトが原因で複数の ping リクエストが失敗し、SageMaker AI はコンテナを `Unhealthy` として検出します。
## Q: `MaxConcurrentInvocationsPerInstance` は、ningx/gunicorn/flask の設定を持つ BYOC モデルコンテナで機能しますか?
はい。`MaxConcurrentInvocationsPerInstance` は非同期エンドポイントの機能です。これはカスタムコンテナの実装には依存しません。`MaxConcurrentInvocationsPerInstance` は呼び出しリクエストがカスタマーコンテナに送信される速度を制御します。この値を `1` として設定すると、カスタマーコンテナに何人のワーカーがいるかに関わらず、一度に 1 つのリクエストのみがコンテナに送信されます。
## Q: 非同期エンドポイントでモデルサーバーエラー (500) をデバッグする方法を教えてください。
このエラーは、カスタマーコンテナがエラーを返したことを意味します。SageMaker AI はカスタマーコンテナの動作を制御しません。SageMaker AI は `ModelContainer` からの応答を返すだけで、再試行は行いません。必要に応じて、失敗時に呼び出しを再試行するように構成できます。コンテナロギングをオンにし、コンテナログを確認して、モデルの 500 エラーの根本原因を見つけることをお勧めします。障害発生時点で、対応する `CPUUtilization` と `MemoryUtilization` メトリクスも確認してください。また、失敗を調査するための非同期エラー通知の一部として、Amazon SNS のモデル応答に [S3FailurePath](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AsyncInferenceOutputConfig.html#sagemaker-Type-AsyncInferenceOutputConfig-S3FailurePath) を設定することもできます。
## Q: `MaxConcurrentInvocationsPerInstance=1` が有効になったかどうかはどうすればわかりますか? 確認できるメトリクスはありますか?
`InvocationsProcesssed` メトリクスを確認できます。単一同時実行に基づいて 1 分間に処理されると予想される呼び出しの数と一致するはずです。
## Q: 呼び出しリクエストの成功と失敗を追跡するにはどうすればよいですか? ベストプラクティスにはどのようなものがありますか？
ベストプラクティスは Amazon SNS を有効にすることです。Amazon SNS は、メッセージング指向のアプリケーション向け通知サービスです。HTTP、Amazon SQS、E メールなどのトランスポートプロトコルの選択肢から、複数のサブスクライバーがタイムクリティカルなメッセージの「プッシュ」通知を要求および受信します。`CreateEndpointConfig` を使用してエンドポイントを作成し、Amazon SNS トピックを指定すると、非同期推論により通知が投稿されます。
Amazon SNS を使って非同期エンドポイントからの予測結果をチェックするには、まずトピックを作成してそのトピックをサブスクライブし、トピックのサブスクリプションを確認してから、そのトピックの Amazon リソースネーム (ARN) を把握しておく必要があります。Amazon SNS トピックの Amazon ARN を作成、サブスクライブ、発見する方法の詳細については、「*Amazon SNS 開発者ガイド*」の「[Amazon SNS を設定する](https://docs.aws.amazon.com/sns/latest/dg/sns-configuring.html)」を参照してください。Amazon SNS を非同期推論で使用する方法の詳細については、「[Check prediction results](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-check-predictions.html)」を参照してください。
## Q: スケーリングポリシーを定義して、新しいリクエストを受信したときにインスタンスをゼロからスケールアップすることはできますか?
はい。非同期推論には、リクエストがない場合にインスタンス数を 0 までスケールダウンするメカニズムがあります。この期間中にエンドポイントのインスタンスがゼロインスタンスにスケールダウンされた場合、キュー内のリクエスト数がスケーリングポリシーで指定された目標を超えるまで、エンドポイントは再びスケールアップされません。その結果、キュー内のリクエストの待ち時間が長くなる可能性があります。このような場合、指定したキューターゲット未満の新しいリクエストに対してゼロインスタンスからスケールアップしたい場合は、`HasBacklogWithoutCapacity` という追加のスケーリングポリシーを使用できます。このスケーリングポリシーの定義方法については、「[非同期エンドポイントをオートスケールする](https://docs.aws.amazon.com/sagemaker/latest/dg/async-inference-autoscale.html#async-inference-autoscale-scale-up)」を参照してください。
## Q: インスタンスタイプが非同期推論でサポートされていないというエラーが表示されます。非同期推論ではどのようなインスタンスタイプがサポートされていますか?
非同期推論でサポートされるインスタンスのリージョン別の一覧については、「[SageMaker の料金](https://aws.amazon.com/sagemaker/pricing/)」を参照してください。先に進む前に、必要なインスタンスがリージョンで利用可能かどうかを確認してください。
# Amazon SageMaker AI による推論のためのバッチ変換
以下を実行する必要がある場合は、バッチ変換を使用します。
+ データセットを前処理して、トレーニングや推論を妨げるノイズやバイアスをデータセットから取り除く場合。
+ 大規模なデータセットから推論を取得する場合。
+ 永続的なエンドポイントが不要なときに推論を実行する場合。
+ 入力レコードを推論に関連付けて結果の解釈に役立てる場合。
推論を実行する前に入力データをフィルタリングしたり、入力レコードをそれらのレコードに関する推論と関連付けるには、[予測結果を入力レコードに関連付ける](batch-transform-data-processing.md) を使用します。たとえば、入力データをフィルタリングして、出力データに関するレポートを作成および解釈するためのコンテキストを提供できます。
**Topics**
+ [バッチ変換を使用して大規模なデータセットから推論を取得する](#batch-transform-large-datasets)
+ [バッチ変換ジョブを高速化する](#batch-transform-reduce-time)
+ [バッチ変換を使用して本番稼働用バリアントをテストする](#batch-transform-test-variants)
+ [バッチ変換のサンプルノートブック](#batch-transform-notebooks)
+ [予測結果を入力レコードに関連付ける](batch-transform-data-processing.md)
+ [バッチ変換での保存](batch-transform-storage.md)
+ [トラブルシューティング](batch-transform-errors.md)
## バッチ変換を使用して大規模なデータセットから推論を取得する
バッチ変換では、指定されたパラメータの範囲内で大規模なデータセットの処理を自動的に管理します。たとえば、S3 バケットに格納されているデータセットファイル `input1.csv` があるとします。入力ファイルの内容は次の例のようになります。
```
Record1-Attribute1, Record1-Attribute2, Record1-Attribute3, ..., Record1-AttributeM
Record2-Attribute1, Record2-Attribute2, Record2-Attribute3, ..., Record2-AttributeM
Record3-Attribute1, Record3-Attribute2, Record3-Attribute3, ..., Record3-AttributeM
...
RecordN-Attribute1, RecordN-Attribute2, RecordN-Attribute3, ..., RecordN-AttributeM
```
バッチ変換ジョブが開始されると、SageMaker AI はコンピューティングインスタンスを起動し、それらの間で推論または前処理のワークロードを分散します。バッチ変換では、キーによって入力の Amazon S3 オブジェクトを分割し、Amazon S3 オブジェクトをインスタンスにマッピングします。複数のファイルがある場合、1 つのインスタンスでは `input1.csv` を処理し、別のインスタンスでは `input2.csv` という名前のファイルを処理する場合があります。入力ファイルが 1 つで、複数のコンピューティングインスタンスを初期化した場合、1 つのインスタンスだけが入力ファイルを処理し、残りのインスタンスはアイドル状態になります。
入力ファイルをミニバッチに分割することもできます。たとえば、レコード群から 2 つのファイルのみを含めることで、`input1.csv` からミニバッチを作成できます。
```
Record3-Attribute1, Record3-Attribute2, Record3-Attribute3, ..., Record3-AttributeM
Record4-Attribute1, Record4-Attribute2, Record4-Attribute3, ..., Record4-AttributeM
```
**注記**
SageMaker AI は、各入力ファイルを別々に処理します。[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB ) の制限に準拠できるよう、別々の入力ファイルのミニバッチは結合されません。
入力ファイルをミニバッチに分割するには、バッチ変換ジョブを作成する際に、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ) パラメータ値を `Line` に設定します。次の場合、SageMaker AI は単一のリクエストで入力ファイル全体を使用します。
+ `SplitType` は `None` に設定されます。
+ 入力ファイルをミニバッチに分割できない。
バッチ変換は、埋め込まれた改行文字を含む CSV 形式の入力をサポートしていません。ミニバッチのサイズは、`[BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-BatchStrategy)` および `[MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxPayloadInMB)` パラメータを使用して制御できます。`MaxPayloadInMB` は 100 MB 以下にする必要があります。オプションの `[MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxConcurrentTransforms)` パラメータを指定する場合、`(MaxConcurrentTransforms * MaxPayloadInMB)` の値も 100 MB 以下にする必要があります。
バッチ変換ジョブが入力ファイル内のすべてのレコードの処理に成功すると、出力ファイルが作成されます。出力ファイルは同じ名前となり、ファイル拡張子 `.out` が付きます。複数の入力ファイル (`input1.csv`、`input2.csv` など) の場合、出力ファイルの名前は `input1.csv.out`、`input2.csv.out` などになります。バッチ変換ジョブでは、Amazon S3 内の指定された場所 (`s3://amzn-s3-demo-bucket/output/` など) に出力ファイルを保存します。
出力ファイル内の予測は、入力ファイルの対応するレコードと同じ順に一覧表示されます。出力ファイル `input1.csv.out` は、前に示した入力ファイルに応じて、次のようになります。
```
Inference1-Attribute1, Inference1-Attribute2, Inference1-Attribute3, ..., Inference1-AttributeM
Inference2-Attribute1, Inference2-Attribute2, Inference2-Attribute3, ..., Inference2-AttributeM
Inference3-Attribute1, Inference3-Attribute2, Inference3-Attribute3, ..., Inference3-AttributeM
...
InferenceN-Attribute1, InferenceN-Attribute2, InferenceN-Attribute3, ..., InferenceN-AttributeM
```
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType ) を `Line` に設定した場合、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ) パラメータを `Line` に設定して出力レコードを行区切り文字で連結できます。出力ファイルの数は変わりません。出力ファイルの数は入力ファイルの数と同じで、`AssembleWith` を使用してもファイルはマージされません。`AssembleWith` パラメータを指定しない場合、デフォルトでは出力レコードはバイナリ形式で連結されます。
入力データが非常に大きく、HTTP チャンクエンコーディングで送信して、データをアルゴリズムにストリーミングする場合、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB) を `0` に設定します。Amazon SageMaker AI の組み込みアルゴリズムではこの機能はサポートされていません。
API を使用してバッチ変換ジョブを作成する方法については、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) API を参照してください。バッチ変換の入力オブジェクトと出力オブジェクトの関係の詳細については、「[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_OutputDataConfig.html)」を参照してください。バッチ変換の使用方法の例については、「[(オプション) バッチ変換を使用して予測を行う](ex1-model-deployment.md#ex1-batch-transform)」を参照してください。
## バッチ変換ジョブを高速化する
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) API を使用している場合は、パラメータに最適値を使用することで、バッチ変換ジョブの完了にかかる時間を短縮できます。これには、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxPayloadInMB)、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-MaxConcurrentTransforms)、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-BatchStrategy) などのパラメータが含まれます。`MaxConcurrentTransforms` の理想的な値は、バッチ変換ジョブに含まれるコンピューティングワーカーの数と同じです。
SageMaker AI コンソールを使用する場合は、**[バッチ変換ジョブの設定]** ページの **[追加設定]** セクションで、これらの最適なパラメータ値を指定します。SageMaker AI は、組み込みアルゴリズムの最適なパラメータ設定を自動的に探します。カスタムアルゴリズムの場合は、これらの値を [execution-parameters](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-batch-code.html#your-algorithms-batch-code-how-containe-serves-requests) エンドポイントを通じて指定します。
## バッチ変換を使用して本番稼働用バリアントをテストする
さまざまなモデル、またはハイパーパラメータ設定をテストするには、新しいモデルバリアントごとに別々の変換ジョブを作成し、検証データセットを使用します。変換ジョブごとに、一意のモデル名と、出力ファイル用の Amazon S3 の場所を指定します。結果を分析するには、[推論パイプラインのログとメトリクス](inference-pipeline-logs-metrics.md) を使用します。
## バッチ変換のサンプルノートブック
バッチ変換を使用するサンプルノートブックについては、[PCA によるバッチ変換と DBSCAN を使用した映画のクラスタリング](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_batch_transform/introduction_to_batch_transform/batch_transform_pca_dbscan_movie_clusters.html)の例を参照してください。このノートブックでは、プリンシパルコンポーネント分析 (PCA) モデルでバッチ変換を行い、ユーザーと項目のレビューマトリックス内のデータを削減します。次に、DBSCAN (Density-Based Spatial Clustering of Applications with Noise) アルゴリズムを使用して映画をクラスタリングする方法について示します。
SageMaker AI でサンプルを実行する際に使用できる Jupyter ノートブックインスタンスを作成してアクセスする手順については、「[Amazon SageMaker ノートブックインスタンス](nbi.md)」を参照してください。ノートブックインスタンスを作成して開いた後、**[SageMaker サンプル]** タブを選択して、すべての SageMaker AI サンプルのリストを表示します。NTM アルゴリズムを使用するトピックモデリングのサンプルノートブックは、**高度な機能**のセクションにあります。ノートブックを開くには、その [**使用**] タブを選び、次に [**コピーを作成**] を選択します。
# 予測結果を入力レコードに関連付ける
大きなデータセットで予測を行う場合、予測に不要な属性を除外できます。予測を行った後で、除外した属性の一部をそれらの予測と関連付けたり、レポート内の他の入力データと関連付けたりすることができます。バッチ変換を使用してこれらのデータ処理ステップを実行することで、多くの場合、追加の前処理や後処理を排除できます。入力ファイルは JSON 形式と CSV 形式でのみ使用できます。
**Topics**
+ [推論を入力レコードに関連付けるワークフロー](#batch-transform-data-processing-workflow)
+ [バッチ変換ジョブでのデータ処理の使用](#batch-transform-data-processing-steps)
+ [サポートされる JSONPath 演算子](#data-processing-operators)
+ [バッチ変換の例](#batch-transform-data-processing-examples)
## 推論を入力レコードに関連付けるワークフロー
次の図は、推論を入力レコードに関連付けるワークフローを示しています。
![\[推論を入力レコードに関連付けるワークフロー。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/batch-transform-data-processing.png)
推論を入力データに関連付けるには、主に 3 つのステップがあります。
1. 入力データをバッチ変換ジョブに渡す前に、推論に不要な入力データをフィルタリングします。[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter ) パラメータを使用して、モデルの入力として使用する属性を決定します。
1. 入力データを推論結果に関連付けます。[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-JoinSource ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-JoinSource ) パラメータを使用して、入力データと推論を結合します。
1. 結合したデータをフィルタリングして、レポート内の予測を解釈するためのコンテキストの提供に必要な入力を保持します。[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-OutputFilter ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-OutputFilter ) を使用して、結合データセットの指定部分を出力ファイルに格納します。
## バッチ変換ジョブでのデータ処理の使用
[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html) でバッチ変換ジョブを作成してデータを処理する場合:
1. `DataProcessing` データ構造内の `InputFilter` パラメータを使用して、モデルに渡す入力部分を指定します。
1. `JoinSource` パラメータを使用して、生の入力データを変換されたデータと結合します。
1. 出力ファイルに含める結合入力部分と、バッチ変換ジョブからの変換済みデータを、`OutputFilter` パラメータで指定します。
1. JSON または CSV 形式のファイルを選択して入力します。
+ JSON 形式または JSON Lines 形式の入力ファイルの場合、SageMaker AI は `SageMakerOutput` 属性を入力ファイルに追加するか、`SageMakerInput` 属性と `SageMakerOutput` 属性を使用して新しい JSON 出力ファイルを作成します。詳細については、「[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataProcessing.html)」を参照してください。
+ CSV 形式の入力ファイルの場合、結合された入力データの後に変換済みデータが続き、CSV ファイルとして出力されます。
`DataProcessing`DataProcessing 構造でアルゴリズムを使用する場合は、入力ファイルと出力ファイルの*両方*で、選択した形式がサポートされている必要があります。例えば、`CreateTransformJob` API の [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html) フィールドの [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#SageMaker-Type-Channel-ContentType) パラメータと [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-Accept](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-Accept) パラメータの両方を `text/csv`、`application/json`、`application/jsonlines` のいずれかの値に設定する必要があります。CSV ファイルの列を指定する構文と JSON ファイルの属性を指定する構文は異なります。誤った構文を使用すると、エラーが発生します。詳細については、「[バッチ変換の例](#batch-transform-data-processing-examples)」を参照してください。組み込みアルゴリズムの入力ファイルと出力ファイルの形式の詳細については、「[Amazon SageMaker の組み込みアルゴリズムと事前トレーニング済みモデル](algos.md)」を参照してください。
入力と出力のレコード区切り文字も、選択したファイルの入力と一致している必要があります。[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformInput.html#SageMaker-Type-TransformInput-SplitType) パラメータは、入力データセットのレコードを分割する方法を示しています。[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TransformOutput.html#SageMaker-Type-TransformOutput-AssembleWith ) パラメータは、出力用にレコードを再構成する方法を示します。入力および出力形式を `text/csv` に設定した場合は、`SplitType` および `AssembleWith` パラメータも `line` に設定する必要があります。入力形式および出力形式を `application/jsonlines` に設定した場合は、`SplitType` と `AssembleWith` の両方を `line` に設定できます。
CSV ファイルの場合、埋め込まれた改行文字は使用できません。JSON ファイルの場合、属性名 `SageMakerOutput` は出力用に予約されています。JSON 入力ファイルにこの名前の属性を含めることはできません。含めた場合、入力ファイルのデータは上書きされる可能性があります。
## サポートされる JSONPath 演算子
入力データと推論をフィルタリングして結合するには、JSONPath 部分式を使用します。SageMaker AI は定義された JSONPath 演算子のサブセットのみをサポートします。次の表に、サポートされる JSONPath 演算子を示します。CSV データの場合、各行は JSON 配列と見なされるため、インデックスベースの JSONPath のみを適用できます (例: `$[0]`、`$[1:]`)。CSV データも [RFC 形式](https://tools.ietf.org/html/rfc4180)に従う必要があります。
| JSONPath 演算子 | 説明 | 例 |
| --- | --- | --- |
| \$1 | クエリするルート要素。この演算子は、すべてのパス式の先頭に必要です。 | \$1 |
| . | ドット表記の子要素。 | `$.id` |
| \$1 | ワイルドカード。属性名または数値の代わりに使用します。 | `$.id.*` |
| ['' (,'')] | 大括弧で表記された要素または複数の子要素。 | `$['id','SageMakerOutput']` |
| [ (,)] | インデックスまたはインデックスの配列。負のインデックス値もサポートされています。`-1` インデックスは配列の最後の要素を表します。 | `$[1]` , `$[1,3,5]` |
| [:] | 配列のスライス演算子。array slice () メソッドは、配列のセクションを抽出し、新しい配列を返します。** を省略すると、SageMaker AI は配列の最初の要素を使用します。** を省略すると、SageMaker AI は配列の最後の要素を使用します。 | `$[2:5]`, `$[:5]`, `$[2:]` |
角かっこ表記を使用して特定のフィールドの複数の子要素を指定する場合、かっこ内に子のネストを追加することはサポートされていません。たとえば、`$.field1.['child1','child2']` はサポートされますが、`$.field1.['child1','child2.grandchild']` はサポートされません。
JSONPath 演算子の詳細については、GitHub の「[JsonPath](https://github.com/json-path/JsonPath)」を参照してください。
## バッチ変換の例
次の例は、入力データと予測結果を結合するための一般的な方法を示しています。
**Topics**
+ [例 : 推論のみを出力する](#batch-transform-data-processing-example-default)
+ [例: 入力データと結合した推論を出力する](#batch-transform-data-processing-example-all)
+ [例: 入力データと結合された推論を出力し、ID 列を入力から除外する (CSV)](#batch-transform-data-processing-example-select-csv)
+ [例: ID 列と結合された推論を出力し、入力から ID 列を除外する (CSV)](#batch-transform-data-processing-example-select-json)
### 例 : 推論のみを出力する
デフォルトでは、[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-DataProcessing](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-CreateTransformJob-request-DataProcessing) パラメータは推論結果を入力と結合しません。推論結果のみが出力されます。
結果を入力と結合しないように明示的に指定する場合、[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) を使用してトランスフォーマー呼び出しで次の設定を指定します。
```
sm_transformer = sagemaker.transformer.Transformer(…)
sm_transformer.transform(…, input_filter="$", join_source= "None", output_filter="$")
```
AWS SDK for Python を使用して推論を出力するには、CreateTransformJob リクエストに次のコードを追加します。以下のコードは、デフォルトの動作を模倣しています。
```
{
"DataProcessing": {
"InputFilter": "$",
"JoinSource": "None",
"OutputFilter": "$"
}
}
```
### 例: 入力データと結合した推論を出力する
[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) を使用して入力データと出力ファイル内の推論を結合する場合は、変換オブジェクトを初期化する際に `assemble_with` パラメータと `accept` パラメータを指定します。変換呼び出しを使用するときは、`join_source` パラメータに `Input` を指定し、`split_type` パラメータおよび `content_type` パラメータも指定します。`split_type` パラメータは `assemble_with` と同じ値、`content_type` パラメータは `accept` と同じ値である必要があります。パラメータと許容値の詳細については、Amazon SageMaker AI Python SDK の「[Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer)」ページを参照してください。
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, join_source="Input", split_type="Line", content_type="text/csv")
```
AWS SDK for Python (Boto 3) を使用している場合は、次のコードを[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)リクエストに追加して、すべての入力データを推論に結合します。`Accept` と `ContentType` の値は一致する必要があり、`AssembleWith` と `SplitType` の値も一致する必要があります。
```
{
"DataProcessing": {
"JoinSource": "Input"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
JSON または JSON Lines の入力ファイルの場合、結果は入力 JSON ファイルの `SageMakerOutput` キーにあります。たとえば、入力がキーと値のペア `{"key":1}` を含む JSON ファイルである場合、データ変換の結果は `{"label":1}` です。
SageMaker AI は、両方を `SageMakerInput` キーの入力ファイル内に保存します。
```
{
"key":1,
"SageMakerOutput":{"label":1}
}
```
**注記**
JSON の結合結果は、キーと値のペアのオブジェクトである必要があります。入力がキーと値のペアのオブジェクトではない場合、SageMaker AI は新しい JSON ファイルを作成します。新しい JSON ファイルで、入力データは `SageMakerInput` キー内に保存され、結果は `SageMakerOutput` 値として保存されます。
たとえば、CSV ファイルで、レコードが `[1,2,3]` で、ラベルの結果が `[1]` の場合、出力ファイルには `[1,2,3,1]` が含まれます。
### 例: 入力データと結合された推論を出力し、ID 列を入力から除外する (CSV)
[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) を使用して入力データを推論出力と結合し、トランスフォーマー入力から ID 列を除外する場合は、トランスフォーマー呼び出しで `input_filter` に前の例と同じパラメータと JSONPath サブエクスプレッションを指定します。例えば、入力データに 5 つの列があり、最初の 1 つが ID 列である場合、次の変換リクエストを使用して、ID 列を除 くすべての列を特徴として選択します。トランスフォーマーは引き続き、推論と結合されたすべての入力列を出力します。パラメータと許容値の詳細については、Amazon SageMaker AI Python SDK の「[Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer)」ページを参照してください。
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, split_type="Line", content_type="text/csv", input_filter="$[1:]", join_source="Input")
```
AWS SDK for Python (Boto 3) を使用している場合は、`[ CreateTransformJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)`リクエストに次のコードを追加します。
```
{
"DataProcessing": {
"InputFilter": "$[1:]",
"JoinSource": "Input"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
SageMaker AI の列を指定するには、配列要素のインデックスを使用します。最初の列はインデックス 0、2 番目の列はインデックス 1、6 番目の列はインデックス 5 です。
入力から最初の列を除外するには、`[InputFilter](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#SageMaker-Type-DataProcessing-InputFilter )` を `"$[1:]"` に設定します。コロン (`:`) は、2 つの値の間のすべての要素を含めるように SageMaker AI に指示します。たとえば、`$[1:4]` は 2 番目から 5 番目の列を指定します。
コロンの後の数字を省略すると (`[5:]` など)、サブセットには 6 番目の列から最後の列までのすべての列が含まれます。コロンの前の数字、たとえば `[:5]` を省略すると、サブセットには最初の列 (インデックス 0) から 6 番目の列までのすべての列が含まれます。
### 例: ID 列と結合された推論を出力し、入力から ID 列を除外する (CSV)
[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) を使用している場合は、トランスフォーマー呼び出しで `output_filter` を指定することで、特定の入力列 (ID 列など) のみを推論と結合するように出力を指定できます。`output_filter` は JSONPath サブ式を使用して、入力データを推論結果と結合した後に出力として返す列を指定します。次のリクエストは、ID 列を除外して予測を行い、ID 列を推論と結合する方法を示しています。次の例では、出力の最後の列 (`-1`) に推論が含まれていることに注意してください。JSON ファイルを使用している場合、SageMaker AI は推論結果を属性 `SageMakerOutput` に保存します。パラメータと許容値の詳細については、Amazon SageMaker AI Python SDK の「[Transformer](https://sagemaker.readthedocs.io/en/stable/api/inference/transformer.html#sagemaker.transformer.Transformer)」ページを参照してください。
```
sm_transformer = sagemaker.transformer.Transformer(…, assemble_with="Line", accept="text/csv")
sm_transformer.transform(…, split_type="Line", content_type="text/csv", input_filter="$[1:]", join_source="Input", output_filter="$[0,-1]")
```
AWS SDK for Python (Boto 3) を使用している場合は、次のコードを[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)リクエストに追加して、ID 列のみを推論と結合します。
```
{
"DataProcessing": {
"InputFilter": "$[1:]",
"JoinSource": "Input",
"OutputFilter": "$[0,-1]"
},
"TransformOutput": {
"Accept": "text/csv",
"AssembleWith": "Line"
},
"TransformInput": {
"ContentType": "text/csv",
"SplitType": "Line"
}
}
```
**警告**
JSON 形式の入力ファイルを使用している場合、ファイルに属性名 `SageMakerOutput` を含めることはできません。この属性名は出力ファイルの推論用に予約されています。この名前の属性が JSON 形式の入力ファイルに含まれていると、入力ファイルの値が推論で上書きされる場合があります。
# バッチ変換での保存
バッチ変換ジョブの実行時に Amazon SageMaker AI は Amazon Elastic Block Store ストレージボリュームをジョブの処理を行う Amazon EC2 インスタンスにアタッチします。ボリュームにはモデルが保存され、ストレージボリュームのサイズは 30 GB に固定されます。ストレージボリューム内の保存中のモデルを暗号化するオプションがあります。
**注記**
大きなモデルをお持ちの場合、`InternalServerError` が発生する場合があります。
Amazon EBS のストレージと機能の詳細については、以下のページを参照してください。
+ 「Amazon EC2 ユーザーガイド」の「[What is Amazon EBS?](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AmazonEBS.html)」
+ 「Amazon EC2 ユーザーガイド」の「[Amazon EBS volumes](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes.html)」
**注記**
G4dn インスタンスには独自のローカル SSD ストレージが付属しています。G4dn インスタンスの詳細については、「[Amazon EC2 G4 インスタンス](https://aws.amazon.com/ec2/instance-types/g4/)」のページを参照してください。
# トラブルシューティング
Amazon SageMaker AI バッチ変換でエラーが発生する場合は、以下のトラブルシューティングのヒントを参照してください。
## 最大タイムアウトエラー
バッチ変換ジョブの実行時に最大タイムアウトエラーが発生する場合は、以下を試してください。
+ まず、単一レコード `[BatchStrategy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-BatchStrategy)`、`[MaxPayloadInMB](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxPayloadInMB)` パラメータで指定したデフォルト (6 MB) 以下のバッチサイズ、および小さなサンプルデータセットから開始します。呼び出しの応答が成功するまで、最大タイムアウトパラメータ `[InvocationsTimeoutInSeconds](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelClientConfig.html#sagemaker-Type-ModelClientConfig-InvocationsTimeoutInSeconds)` (最大 1 時間) を調整します。
+ 呼び出しレスポンスを正常に受信したら、`MaxPayloadInMB` (最大 100 MB) `InvocationsTimeoutInSeconds` とパラメータを増やし、希望するモデルのタイムアウトに対応できる最大バッチサイズを見つけます。このステップでは、単一レコードまたはマルチレコード `BatchStrategy` のいずれかを使用できます。
**注記**
`MaxPayloadInMB` 制限を超過すると、エラーになります。このエラーは、分割できない場合、`SplitType` パラメータが「なし」に設定されている場合、またはデータセット内の個々のレコードが制限を超えている場合に大規模なデータセットで発生する可能性があります。
+ (オプション) バッチ変換ジョブの各インスタンスに送信できる並列リクエストの最大数を指定する `[MaxConcurrentTransforms](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html#sagemaker-CreateTransformJob-request-MaxConcurrentTransforms)` パラメータを調整します。ただし、`MaxConcurrentTransforms * MaxPayloadInMB` の値は 100 MB 以下にする必要があります。
## 不完全な出力
SageMaker AI は、Amazon S3 の[マルチパートアップロード API](https://docs.aws.amazon.com/AmazonS3/latest/dev/uploadobjusingmpu.html) を使用して、バッチ変換ジョブの結果を Amazon S3 にアップロードします。エラーが発生すると、アップロードした結果が Amazon S3 から削除されます。ネットワーク停止が発生するなどの状況では、不完全なマルチパートアップロードが Amazon S3 に残ることがあります。入力ファイルが複数あり、一部のファイルが SageMaker AI バッチ変換で処理できない場合にも、不完全なアップロードが発生することがあります。Amazon S3 には、処理できなかった入力ファイルに対応する出力ファイルはありません。
ストレージ料金が発生しないように、S3 バケットライフサイクルルールに [S3 バケットポリシー](https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config)を追加することをお勧めします。このポリシーは、S3 バケットに保存されている可能性がある不完全なマルチパートアップロードを削除します。詳細については、「[オブジェクトのライフサイクル管理](https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lifecycle-mgmt.html)」を参照してください。
## ジョブは `failed` として表示されます。
データセットに問題があるためにバッチ変換ジョブが入力ファイルの処理に失敗すると、SageMaker AI はジョブを `failed` とマークします。入力ファイルに不正なレコードが含まれている場合は、入力ファイルと同じ順番を変換済みデータで維持できないため、この入力ファイルの出力ファイルは変換ジョブで作成されません。データセットに複数の入力ファイルが含まれている場合は、1 つの入力ファイルの処理に失敗しても、変換ジョブは入力ファイルの処理を続行します。処理済みのファイルからは依然として使用可能な結果が生成されます。
独自のアルゴリズムを使用している場合、このアルゴリズムは、入力ファイル内に不正なレコードを見つけると、`ERROR` などのプレースホルダーテキストを使用できます。たとえば、データセット内の最終レコードが不正である場合、アルゴリズムは、そのレコードのプレースホルダーテキストを出力ファイル内に配置します。
# モデル並列処理と大規模モデル推論
Amazon SageMaker AI には、モデル並列化処理と大規模モデル推論 (LMI) のための特殊なディープラーニングコンテナ (DLC)、ライブラリ、ツールが含まれています。以下のセクションでは、SageMaker AI で LMI の使用を開始するためのリソースを見つけることができます。
**Topics**
+ [大規模モデル推論 (LMI) コンテナのドキュメント](large-model-inference-container-docs.md)
+ [大規模モデル推論用の SageMaker AI エンドポイントパラメータ](large-model-inference-hosting.md)
+ [非圧縮モデルのデプロイ](large-model-inference-uncompressed.md)
+ [TorchServe で推論用の大規模モデルをデプロイする](large-model-inference-tutorials-torchserve.md)
# 大規模モデル推論 (LMI) コンテナのドキュメント
[大規模モデル推論 (LMI) コンテナのドキュメント](https://docs.djl.ai/master/docs/serving/serving/docs/lmi/index.html)は、Deep Java Library ドキュメントのサイトに掲載されています。
このドキュメントは、Amazon SageMaker AI で大規模言語モデル (LLM) をデプロイおよび最適化する必要があるデベロッパー、データサイエンティスト、機械学習エンジニア向けに書かれています。これにより、 が提供する LLM 推論専用の Docker コンテナである LMI コンテナを使用できます AWS。内容としては、概要、デプロイガイド、サポート対象の推論ライブラリのユーザーガイド、高度なチュートリアルを扱っています。
LMI コンテナのドキュメントを参考にすると、以下のことがわかります。
+ LMI コンテナのコンポーネントとアーキテクチャを理解する
+ ユースケースに適したインスタンスタイプとバックエンドの選択方法がわかる
+ SageMaker AI で LMI コンテナを使用して LLM を設定およびデプロイする
+ 量子化、テンソル並列処理、連続バッチ処理などの機能を使用して、パフォーマンスを最適化する
+ SageMaker AI エンドポイントのベンチマークとチューニングを行い、最適なスループットとレイテンシーを実現する
# 大規模モデル推論用の SageMaker AI エンドポイントパラメータ
以下のパラメータをカスタマイズして、SageMaker AI を使用した低レイテンシーの大規模モデル推論 (LMI) を容易にすることができます。
+ **インスタンスの Amazon EBS ボリュームの最大サイズ (`VolumeSizeInGB`)** — モデルのサイズが 30 GB より大きく、ローカルディスクのないインスタンスを使用している場合は、このパラメータをモデルのサイズより少し大きくする必要があります。
+ **ヘルスチェックのタイムアウトクォータ (`ContainerStartupHealthCheckTimeoutInSeconds`)** — コンテナが正しく設定されていて、CloudWatch ログにヘルスチェックのタイムアウトが示されている場合は、コンテナがヘルスチェックに応答するのに十分な時間を確保できるように、このクォータを増やす必要があります。
+ **モデルダウンロードのタイムアウトクォータ (`ModelDataDownloadTimeoutInSeconds`)** — モデルのサイズが 40 GB より大きい場合は、Amazon S3 からインスタンスにモデルをダウンロードするのに十分な時間を確保するために、このクォータを増やす必要があります。
次のコードスニペットは、前述のパラメータをプログラム的に設定する方法を示しています。サンプルの*イタリック体のプレースホルダーテキスト*を独自の情報に置き換えます。
```
import boto3
aws_region = "aws-region"
sagemaker_client = boto3.client('sagemaker', region_name=aws_region)
# The name of the endpoint. The name must be unique within an AWS Region in your AWS account.
endpoint_name = "endpoint-name"
# Create an endpoint config name.
endpoint_config_name = "endpoint-config-name"
# The name of the model that you want to host.
model_name = "the-name-of-your-model"
instance_type = "instance-type"
sagemaker_client.create_endpoint_config(
EndpointConfigName = endpoint_config_name
ProductionVariants=[
{
"VariantName": "variant1", # The name of the production variant.
"ModelName": model_name,
"InstanceType": instance_type, # Specify the compute instance type.
"InitialInstanceCount": 1, # Number of instances to launch initially.
"VolumeSizeInGB": 256, # Specify the size of the Amazon EBS volume.
"ModelDataDownloadTimeoutInSeconds": 1800, # Specify the model download timeout in seconds.
"ContainerStartupHealthCheckTimeoutInSeconds": 1800, # Specify the health checkup timeout in seconds
},
],
)
sagemaker_client.create_endpoint(EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name)
```
`ProductionVariants` のキーの詳細については、「[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html)」を参照してください。
大規模なモデルで低レイテンシーの推論を実現する方法の例については、aws-samples GitHub リポジトリの「[Generative AI Inference Examples on Amazon SageMaker AI](https://github.com/aws-samples/sagemaker-genai-hosting-examples/tree/main)」を参照してください。
# 非圧縮モデルのデプロイ
ML モデルをデプロイする場合、モデルアーティファクトを `tar.gz` フォーマットにアーカイブして圧縮するという方法があります。この方法は小さなモデルには適していますが、数千億のパラメータを含む大規模なモデルアーティファクトを圧縮し、エンドポイントで解凍するにはかなりの時間がかかる場合があります。大規模なモデル推論には、非圧縮 ML モデルをデプロイすることをお勧めします。このガイドでは、非圧縮 ML モデルをデプロイする方法を説明します。
非圧縮 ML モデルをデプロイするには、すべてのモデルアーティファクトを Amazon S3 にアップロードし、共通の Amazon S3 プレフィックスで整理します。Amazon S3 プレフィックスは、Amazon S3 オブジェクトキー名の先頭にある文字列で、名前の残りの部分と区切り文字で区切られています。プレフィックスの詳細については、「[プレフィックスを使用してオブジェクトを整理する](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-prefixes.html)」を参照してください。
SageMaker AI でデプロイする場合は、区切り文字としてスラッシュ (/) を使用する必要があります。ML モデルに関連するアーティファクトのみがプレフィックスで整理されていることを確認する必要があります。単一の圧縮されていないアーティファクトを持つ ML モデルの場合、プレフィックスはキー名と同じになります。どのオブジェクトがプレフィックスに関連付けられているかは、AWS CLI で確認できます。
```
aws s3 ls --recursive s3://bucket/prefix
```
モデルアーティファクトを Amazon S3 にアップロードし、共通のプレフィックスで整理した後、[CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html) リクエストを呼び出す際に [ModelDataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelDataSource.html) フィールドの一部としてその場所を指定できます SageMaker AI は、推論用に圧縮されていないモデルアーティファクトを自動的に `/opt/ml/model` にダウンロードします。アーティファクトをダウンロードするときに SageMaker AI が適用するルールの詳細については、「[S3ModelDataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3ModelDataSource.html)」を参照してください。
以下のコードスニペットは、非圧縮モデルをデプロイするときに `CreateModel` API を呼び出す方法を示しています。*イタリック体のユーザーテキスト*を独自の情報に置き換えます。
```
model_name = "model-name"
sagemaker_role = "arn:aws:iam::123456789012:role/SageMakerExecutionRole"
container = "123456789012.dkr.ecr.us-west-2.amazonaws.com/inference-image:latest"
create_model_response = sagemaker_client.create_model(
ModelName = model_name,
ExecutionRoleArn = sagemaker_role,
PrimaryContainer = {
"Image": container,
"ModelDataSource": {
"S3DataSource": {
"S3Uri": "s3://amzn-s3-demo-bucket/prefix/to/model/data/",
"S3DataType": "S3Prefix",
"CompressionType": "None",
},
},
},
)
```
前述の例では、モデルアーティファクトが共通のプレフィックスの下に整理されていることを前提としています。モデルアーティファクトが単一の非圧縮 Amazon S3 オブジェクトである場合は、`"S3Uri"` を Amazon S3 オブジェクトを指すように変更し、`"S3DataType"` を `"S3Object"` に変更します。
**注記**
現在、`ModelDataSource` を AWS Marketplace、SageMaker AI バッチ変換、SageMaker サーバーレス推論エンドポイント、および SageMaker マルチモデルエンドポイントで使用することはできません。
# TorchServe で推論用の大規模モデルをデプロイする
このチュートリアルでは、TorchServe を使用して、GPU 上で Amazon SageMaker AI に大規模なモデルをデプロイし、推論を提供する方法を紹介します。この例では、[OPT-30b](https://huggingface.co/facebook/opt-30b) モデルを `ml.g5` インスタンスにデプロイします。これを変更して、他のモデルやインスタンスタイプと連携できます。例に出現する `italicized placeholder text` は、実際の情報に置き換えてください。
TorchServe は、大規模な分散モデル推論向けの強力なオープンプラットフォームです。PyTorch、ネイティブ PiPPy、DeepSpeed、HuggingFace Accelerate などの一般的なライブラリをサポートしており、分散型の大規模モデルおよび非分散モデルのどちらの推論シナリオでも一貫性のある、統一のハンドラー API を提供します。詳細については、[TorchServe の大規模モデル推論のドキュメント](https://pytorch.org/serve/large_model_inference.html#)を参照してください。
## TorchServe を使用した深層学習コンテナ
TorchServe を使用して SageMaker AI で大規模モデルをデプロイするには、SageMaker AI 深層学習コンテナ (DLC) のいずれかを使用できます。デフォルトでは、TorchServe はすべての AWS PyTorch DLCs。モデルのロード中に、TorchServe は PiPPy、Deepspeed、Accelerate などの大規模モデルに特化したライブラリをインストールする場合があります。
次の表は、[TorchServe を使用する SageMaker AI DLC](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) を網羅した一覧です。
| DLC カテゴリ | フレームワーク | ハードウェア | URL の例 |
| --- | --- | --- | --- |
| [SageMaker AI フレームワークコンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) | PyTorch 2.0.0 以降 | CPU、GPU | 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-inference:2.0.1-gpu-py310-cu118-ubuntu20.04-sagemaker |
| [SageMaker AI フレームワーク Graviton コンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) | PyTorch 2.0.0 以降 | CPU | 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-inference-graviton:2.0.1-cpu-py310-ubuntu20.04-sagemaker |
| [StabilityAI 推論コンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#stabilityai-inference-containers) | PyTorch 2.0.0 以降 | GPU | 763104351884.dkr.ecr.us-east-1.amazonaws.com/stabilityai-pytorch-inference:2.0.1-sgm0.1.0-gpu-py310-cu118-ubuntu20.04-sagemaker |
| [Neuron コンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) | PyTorch 1.13.1 | Neuronx | 763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-inference-neuron:1.13.1-neuron-py310-sdk2.12.0-ubuntu20.04 |
## 開始方法
モデルをデプロイする前に、前提条件が満たされているか確認してください。また、モデルパラメータを設定し、ハンドラーコードをカスタマイズすることもできます。
### 前提条件
開始するには、次の前提条件が整っていることを確認してください。
1. AWS アカウントにアクセスできることを確認します。[が IAM ユーザーまたは IAM ロールを介してアカウントにアクセスできるように環境を設定します](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)。 AWS CLI AWS IAM ロールの使用をお勧めします。個人アカウントでテストする目的で、以下の管理アクセス許可ポリシーを IAM ロールにアタッチできます。
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWSServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
IAM ポリシーのロールへのアタッチに関する詳細については、「*AWS IAM ユーザーガイド*」の「[IAM ID のアクセス許可の追加および削除](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html)」を参照してください。
1. 次の例に示すように、依存関係をローカルに設定します。
1. のバージョン 2 をインストールします AWS CLI。
```
# Install the latest AWS CLI v2 if it is not installed
!curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" !unzip awscliv2.zip
#Follow the instructions to install v2 on the terminal
!cat aws/README.md
```
1. SageMaker AI と Boto3 クライアントをインストールします。
```
# If already installed, update your client
#%pip install sagemaker pip --upgrade --quiet
!pip install -U sagemaker
!pip install -U boto
!pip install -U botocore
!pip install -U boto3
```
### モデル設定とパラメータを設定する
TorchServe は [https://pytorch.org/docs/stable/elastic/run.html](https://pytorch.org/docs/stable/elastic/run.html) を使用して、モデル並列処理用の分散環境を設定します。TorchServe には、大規模なモデルに対して複数のワーカーをサポートする機能があります。デフォルトでは、TorchServe はラウンドロビンアルゴリズムを使用して、ホスト上のワーカーに GPU を割り当てます。モデル推論が大規模な場合、各ワーカーに割り当てられる GPU の数は、`model_config.yaml` ファイルで指定された GPU の数に基づいて自動的に計算されます。特定の時点で使用可能な GPU デバイスの ID を指定する環境変数 `CUDA_VISIBLE_DEVICES` は、この数に基づいて設定されます。
例えば、1 つのノードに GPU が 8 つあり、1 つのワーカーがそのノードで 4 つの GPU を必要とするとします (`nproc_per_node=4`)。この場合、TorchServe は最初のワーカーに 4 つの GPU を割り当て (`CUDA_VISIBLE_DEVICES="0,1,2,3"`)、2 番目のワーカーに 4 つの GPU を割り当てます (`CUDA_VISIBLE_DEVICES="4,5,6,7”`)。
このデフォルトの動作に加えて、TorchServe では、ユーザーが柔軟にワーカーの GPU 数を指定することができます。例えば、[モデル設定の YAML ファイル](https://github.com/pytorch/serve/blob/5ee02e4f050c9b349025d87405b246e970ee710b/model-archiver/README.md?plain=1#L164)で変数 `deviceIds: [2,3,4,5]` を設定し、`nproc_per_node=2` を設定した場合、TorchServe は最初のワーカーに `CUDA_VISIBLE_DEVICES="4,5”`、2 番目のワーカーに `CUDA_VISIBLE_DEVICES=”2,3”` を割り当てます。
次の `model_config.yaml` の例では、[OPT-30b](https://huggingface.co/facebook/opt-30b) モデルのフロントエンドパラメータとバックエンドパラメータの両方を設定しています。設定されたフロントエンドパラメータは、`parallelType`、`deviceType`、`deviceIds `、`torchrun` です。設定できるフロントエンドパラメータの詳細については、[PyTorch GitHub のドキュメント](https://github.com/pytorch/serve/blob/2bf505bae3046b0f7d0900727ec36e611bb5dca3/docs/configuration.md?plain=1#L267)を参照してください。バックエンド設定は、フリースタイルのカスタマイズを許可する YAML マップに基づいています。バックエンドパラメータについては、DeepSpeed 設定とカスタムハンドラーコードで使用される追加のパラメータを定義します。
```
# TorchServe front-end parameters
minWorkers: 1
maxWorkers: 1
maxBatchDelay: 100
responseTimeout: 1200
parallelType: "tp"
deviceType: "gpu"
# example of user specified GPU deviceIds
deviceIds: [0,1,2,3] # sets CUDA_VISIBLE_DEVICES
torchrun:
nproc-per-node: 4
# TorchServe back-end parameters
deepspeed:
config: ds-config.json
checkpoint: checkpoints.json
handler: # parameters for custom handler code
model_name: "facebook/opt-30b"
model_path: "model/models--facebook--opt-30b/snapshots/ceea0a90ac0f6fae7c2c34bcb40477438c152546"
max_length: 50
max_new_tokens: 10
manual_seed: 40
```
### ハンドラーをカスタマイズする
TorchServe は、大規模なモデル推論用に、一般的なライブラリで構築された[ベースハンドラー](https://github.com/pytorch/serve/tree/master/ts/torch_handler/distributed)と[ハンドラーユーティリティ](https://github.com/pytorch/serve/tree/master/ts/handler_utils)を提供しています。次の例では、カスタムハンドラークラスの [TransformersSeqClassifierHandler](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/examples/large_models/deepspeed/custom_handler.py#L16C7-L16C39) で [BaseDeepSpeedHandler](https://github.com/pytorch/serve/blob/ab69b69a59d6ca6074df7e6d4014f07eb48dedba/ts/torch_handler/distributed/base_deepspeed_handler.py#L8) を拡張し、[ハンドラーユーティリティ](https://github.com/pytorch/serve/blob/master/ts/handler_utils/distributed/deepspeed.py)を使用する方法を示しています。完全なコード例については、[PyTorch GitHub ドキュメントの `custom_handler.py` コード](https://github.com/pytorch/serve/blob/master/examples/large_models/deepspeed/custom_handler.py)を参照してください。
```
class TransformersSeqClassifierHandler(BaseDeepSpeedHandler, ABC):
"""
Transformers handler class for sequence, token classification and question answering.
"""
def __init__(self):
super(TransformersSeqClassifierHandler, self).__init__()
self.max_length = None
self.max_new_tokens = None
self.tokenizer = None
self.initialized = False
def initialize(self, ctx: Context):
"""In this initialize function, the HF large model is loaded and
partitioned using DeepSpeed.
Args:
ctx (context): It is a JSON Object containing information
pertaining to the model artifacts parameters.
"""
super().initialize(ctx)
model_dir = ctx.system_properties.get("model_dir")
self.max_length = int(ctx.model_yaml_config["handler"]["max_length"])
self.max_new_tokens = int(ctx.model_yaml_config["handler"]["max_new_tokens"])
model_name = ctx.model_yaml_config["handler"]["model_name"]
model_path = ctx.model_yaml_config["handler"]["model_path"]
seed = int(ctx.model_yaml_config["handler"]["manual_seed"])
torch.manual_seed(seed)
logger.info("Model %s loading tokenizer", ctx.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.tokenizer.pad_token = self.tokenizer.eos_token
config = AutoConfig.from_pretrained(model_name)
with torch.device("meta"):
self.model = AutoModelForCausalLM.from_config(
config, torch_dtype=torch.float16
)
self.model = self.model.eval()
ds_engine = get_ds_engine(self.model, ctx)
self.model = ds_engine.module
logger.info("Model %s loaded successfully", ctx.model_name)
self.initialized = True
def preprocess(self, requests):
"""
Basic text preprocessing, based on the user's choice of application mode.
Args:
requests (list): A list of dictionaries with a "data" or "body" field, each
containing the input text to be processed.
Returns:
tuple: A tuple with two tensors: the batch of input ids and the batch of
attention masks.
"""
def inference(self, input_batch):
"""
Predicts the class (or classes) of the received text using the serialized transformers
checkpoint.
Args:
input_batch (tuple): A tuple with two tensors: the batch of input ids and the batch
of attention masks, as returned by the preprocess function.
Returns:
list: A list of strings with the predicted values for each input text in the batch.
"""
def postprocess(self, inference_output):
"""Post Process Function converts the predicted response into Torchserve readable format.
Args:
inference_output (list): It contains the predicted response of the input text.
Returns:
(list): Returns a list of the Predictions and Explanations.
"""
```
## モデルのアーティファクトの準備
SageMaker AI にモデルをデプロイする前に、モデルアーティファクトをパッケージ化する必要があります。大規模モデルの場合は、引数 `--archive-format no-archive` を指定して PyTorch の [torch-model-archiver](https://github.com/pytorch/serve/blob/master/model-archiver/README.md) ツールを使用することをお勧めします。この引数を指定した場合、モデルアーティファクトの圧縮がスキップされます。次の例では、すべてのモデルアーティファクトを `opt/` という名前の新しいフォルダに保存します。
```
torch-model-archiver --model-name opt --version 1.0 --handler custom_handler.py --extra-files ds-config.json -r requirements.txt --config-file opt/model-config.yaml --archive-format no-archive
```
`opt/` フォルダを作成したら、PyTorch の [Download\$1model](https://github.com/pytorch/serve/blob/master/examples/large_models/utils/Download_model.py) ツールを使用して、OPT-30b モデルをそのフォルダにダウンロードします。
```
cd opt
python path_to/Download_model.py --model_path model --model_name facebook/opt-30b --revision main
```
最後に、モデルアーティファクトを Amazon S3 バケットにアップロードします。
```
aws s3 cp opt {your_s3_bucket}/opt --recursive
```
これで、モデルアーティファクトが Amazon S3 に保存され、SageMaker AI エンドポイントにデプロイできるようになります。
## SageMaker Python SDK を使用してモデルをデプロイする
モデルアーティファクトを準備したら、モデルを SageMaker AI ホスティングエンドポイントにデプロイできます。このセクションでは、単一の大きなモデルをエンドポイントにデプロイし、ストリーミング応答の予測を行う方法について説明します。エンドポイントからの応答のストリーミングの詳細については、「[リアルタイムエンドポイントを呼び出す](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-test-endpoints.html)」を参照してください。
モデルをデプロイするには、次の手順を実行します。
1. SageMaker AI セッションを作成します。次の例を参照してください。
```
import boto3
import sagemaker
from sagemaker import Model, image_uris, serializers, deserializers
boto3_session=boto3.session.Session(region_name="us-west-2")
smr = boto3.client('sagemaker-runtime-demo')
sm = boto3.client('sagemaker')
role = sagemaker.get_execution_role() # execution role for the endpoint
sess= sagemaker.session.Session(boto3_session, sagemaker_client=sm, sagemaker_runtime_client=smr) # SageMaker AI session for interacting with different AWS APIs
region = sess._region_name # region name of the current SageMaker Studio Classic environment
account = sess.account_id() # account_id of the current SageMaker Studio Classic environment
# Configuration:
bucket_name = sess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}"
print(f'account={account}, region={region}, role={role}, output_path={output_path}')
```
1. SageMaker AI で非圧縮モデルを作成します。次の例を参照してください。
```
from datetime import datetime
instance_type = "ml.g5.24xlarge"
endpoint_name = sagemaker.utils.name_from_base("ts-opt-30b")
s3_uri = {your_s3_bucket}/opt
model = Model(
name="torchserve-opt-30b" + datetime.now().strftime("%Y-%m-%d-%H-%M-%S"),
# Enable SageMaker uncompressed model artifacts
model_data={
"S3DataSource": {
"S3Uri": s3_uri,
"S3DataType": "S3Prefix",
"CompressionType": "None",
}
},
image_uri=container,
role=role,
sagemaker_session=sess,
env={"TS_INSTALL_PY_DEP_PER_MODEL": "true"},
)
print(model)
```
1. モデルを Amazon EC2 インスタンスにデプロイします。次の例を参照してください。
```
model.deploy(
initial_instance_count=1,
instance_type=instance_type,
endpoint_name=endpoint_name,
volume_size=512, # increase the size to store large model
model_data_download_timeout=3600, # increase the timeout to download large model
container_startup_health_check_timeout=600, # increase the timeout to load large model
)
```
1. ストリーミング応答を処理するクラスを初期化します。次の例を参照してください。
```
import io
class Parser:
"""
A helper class for parsing the byte stream input.
The output of the model will be in the following format:
```
b'{"outputs": [" a"]}\n'
b'{"outputs": [" challenging"]}\n'
b'{"outputs": [" problem"]}\n'
...
```
While usually each PayloadPart event from the event stream will contain a byte array
with a full json, this is not guaranteed and some of the json objects may be split across
PayloadPart events. For example:
```
{'PayloadPart': {'Bytes': b'{"outputs": '}}
{'PayloadPart': {'Bytes': b'[" problem"]}\n'}}
```
This class accounts for this by concatenating bytes written via the 'write' function
and then exposing a method which will return lines (ending with a '\n' character) within
the buffer via the 'scan_lines' function. It maintains the position of the last read
position to ensure that previous bytes are not exposed again.
"""
def __init__(self):
self.buff = io.BytesIO()
self.read_pos = 0
def write(self, content):
self.buff.seek(0, io.SEEK_END)
self.buff.write(content)
data = self.buff.getvalue()
def scan_lines(self):
self.buff.seek(self.read_pos)
for line in self.buff.readlines():
if line[-1] != b'\n':
self.read_pos += len(line)
yield line[:-1]
def reset(self):
self.read_pos = 0
```
1. ストリーミング応答の予測をテストします。次の例を参照してください。
```
import json
body = "Today the weather is really nice and I am planning on".encode('utf-8')
resp = smr.invoke_endpoint_with_response_stream(EndpointName=endpoint_name, Body=body, ContentType="application/json")
event_stream = resp['Body']
parser = Parser()
for event in event_stream:
parser.write(event['PayloadPart']['Bytes'])
for line in parser.scan_lines():
print(line.decode("utf-8"), end=' ')
```
これで、モデルを SageMaker AI エンドポイントにデプロイし、応答を得るために呼び出せるようになったはずです。SageMaker AI リアルタイムエンドポイントの詳細については、「[シングルモデルエンドポイント](realtime-single-model.md)」を参照してください。
# 本番環境でモデルを更新するためのデプロイガードレール
デプロイガードレールは、本番環境で機械学習モデルを更新するための Amazon SageMaker AI 推論の一連のモデルデプロイオプションです。このフルマネージドデプロイオプションを使うと、本番環境の現在のモデルから新しいモデルへの切り替えをコントロールできます。Canary や Linear など、ブルー/グリーンデプロイのトラフィックシフトモードにより、更新の過程で現在のモデルから新しいモデルへのトラフィックシフトプロセスを細かくコントロールできます。また、自動ロールバックなどの組み込みセーフガードもあり、本番環境に大きな影響を与える前に、問題を早期に検出し、自動的に是正措置を講じることができます。
デプロイガードレールには次の利点があります。
+ **本番環境を更新する際のデプロイの安全性。**本番環境に対して後退的更新を行うと、計画外のダウンタイムが発生し、モデルのレイテンシーの増加や高いエラー率など、ビジネスに影響を与える可能性があります。デプロイガードレールは、ベストプラクティスと組み込みオペレーションの安全なガードレールを提供することで、これらのリスクを軽減するのに役立ちます。
+ **フルマネージドデプロイ。**SageMaker AI がこれらのデプロイの設定とオーケストレーションを行い、エンドポイント更新メカニズムと統合します。お客様がオーケストレーション、モニタリング、ロールバックのメカニズムを構築、維持する必要はありません。お客様は SageMaker AI を活用してデプロイの設定やオーケストレーションを行い、アプリケーションへの ML の活用に集中できます。
+ **可視性。**デプロイの進行状況は、[DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) API または Amazon CloudWatch Events ([サポートされているエンドポイント](deployment-guardrails-exclusions.md)の場合) を通じて追跡できます。SageMaker AI のイベントの詳細については、「[Amazon SageMaker AI が Amazon EventBridge に送信するイベント](automating-sagemaker-with-eventbridge.md)」の「エンドポイントデプロイの状態変更」セクションを参照してください。エンドポイントが「[Exclusions](deployment-guardrails-exclusions.md)」ページのいずれかの機能を使っている場合、CloudWatch Events は使用できないことに注意してください。
**注記**
デプロイガードレールは [非同期推論](async-inference.md) エンドポイントタイプと [リアルタイム推論](realtime-endpoints.md) エンドポイントタイプにのみ適用されます。
## 開始方法
実稼働環境でのモデルの更新には、Blue/Green デプロイとローリングデプロイの 2 種類のデプロイがサポートされています。
+ [ブルー/グリーンデプロイ](deployment-guardrails-blue-green.md): 更新により、古いフリート (青のフリート) から新しいフリート (緑のフリート) にトラフィックをシフトさせることができます。Blue/Green デプロイは[複数のトラフィックシフトモード](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-blue-green.html)を提供します。トラフィックシフトモードとは、SageMaker AI がエンドポイントトラフィックを、お客様の更新を含む新しいフリートにどのようにルーティングするかを指定する設定です。次のトラフィックシフトモードでは、エンドポイントの更新プロセスをさまざまなレベルでコントロールできます。
+ [All At Once トラフィックシフトを使用する](deployment-guardrails-blue-green-all-at-once.md) は、すべてのエンドポイントトラフィックを青のフリートから緑のフリートにシフトします。トラフィックが緑のフリートにシフトすると、事前に指定した Amazon CloudWatch アラームが一定期間 (*ベーキング期間*)、緑のフリートのモニタリングを開始します。ベーキング期間中にアラームが作動しない場合、SageMaker AI は青のフリートを終了します。
+ [Canary トラフィックシフトを使用する](deployment-guardrails-blue-green-canary.md) では、トラフィックのごく一部 (canary) を緑のフリートにシフトして、ベーキング期間中それをモニタリングできます。**canary が緑のフリートで成功すると、SageMaker AI は青のフリートを終了する前に残りのトラフィックを青のフリートから緑のフリートにシフトします。
+ [Linear トラフィックシフトを使用する](deployment-guardrails-blue-green-linear.md) は、トラフィックシフトステップの数と各ステップでシフトするトラフィックの割合をさらにカスタマイズできます。Canary シフトではトラフィックを 2 つのステップでシフトできますが、Linear シフトはこれを *n* 個の線形間隔のステップに拡張します。
+ [ローリングデプロイを使用する](deployment-guardrails-rolling.md): SageMaker AI がキャパシティを段階的にプロビジョニングし、指定したバッチサイズのステップでトラフィックを新しいフリートにシフトするのに合わせて、エンドポイントを更新できます。新しいフリートのインスタンスは新しいデプロイ設定で更新され、ベイク期間中に CloudWatch アラームが発生しない場合、SageMaker AI は古いフリートのインスタンスをクリーンアップします。このオプションにより、各ステップで移行するインスタンス数または容量の割合をきめ細かく制御できます。
[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) と [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) SageMaker API、および AWS Command Line Interface コマンドを使用して、デプロイを作成、管理できます。デプロイの設定方法の詳細については、個々のデプロイページを参照してください。エンドポイントが「[Exclusions](deployment-guardrails-exclusions.md)」ページにリストされているいずれかの機能を使っている場合、デプロイガードレールは使用できないことに注意してください。
デプロイガードレールの使用方法を示すガイド付きの例に従うには、Canary および Linear トラフィックシフトモードの[Jupyter ノートブック](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-inference-deployment-guardrails)の例を参照してください。
# 設定とモニタリングを自動ロールバックする
Amazon CloudWatch アラームは、デプロイガードレールでベーキング期間を使うための前提条件です。デプロイガードレールにおける自動ロールバック機能は、エンドポイントをモニタリングできる CloudWatch アラームを設定した場合にのみ、使用できます。指定したモニタリング期間中にアラームが作動生した場合、SageMaker AI はアプリケーションを保護するために古いエンドポイントへの完全なロールバックを開始します。エンドポイントをモニタリングするように CloudWatch アラームを設定していない場合、デプロイ中に自動ロールバック機能は機能しません。
Amazon CloudWatch の詳細については、[Amazon CloudWatch ユーザーガイド](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html)の「*Amazon CloudWatch とは*」を参照してください。
**注記**
IAM 実行ロールに、指定した自動ロールバックアラームの `cloudwatch:DescribeAlarms` アクションを実行するアクセス許可があることを確認してください。
## アラームの例
開始に役立つよう、CloudWatch アラームの機能をデモする以下の例を用意しました。次の例の使用または変更するだけでなく、独自のアラームを作成し、指定したフリートのさまざまなメトリクスを一定期間モニタリングするようにアラームを設定できます。アラームに追加できる SageMaker AI のメトリクスとディメンションの詳細については、「[Amazon CloudWatch における Amazon SageMaker AI メトリクス](monitoring-cloudwatch.md)」を参照してください。
**Topics**
+ [新旧両方のフリートの呼び出しエラーをモニタリングする](#deployment-guardrails-configuration-alarm-examples-errors-both)
+ [新しいフリートのモデルのレイテンシーをモニタリングする](#deployment-guardrails-configuration-alarm-examples-latency-new)
### 新旧両方のフリートの呼び出しエラーをモニタリングする
次の CloudWatch アラームは、エンドポイントの平均エラー率をモニタリングします。このアラームを任意のデプロイガードレールのトラフィックシフトタイプで使うことで、新旧両方のフリートで全体的なモニタリングを行うことができます。アラームが作動すると、SageMaker AI は古いフリートへのロールバックを開始します。
新旧両方のフリートから発生する呼び出しエラーは、平均エラー率に影響します。平均エラー率が指定されたしきい値を超えると、アラームが作動します。この例では、デプロイ期間中、新旧両方のフリートで 4xx エラー (クライアントエラー) をモニタリングします。メトリクス `Invocation5XXErrors` を使って 5xx エラー (サーバーエラー) をモニタリングすることもできます。
**注記**
このアラームタイプでは、デプロイ中に古いフリートでアラームが作動すると、SageMaker AI はデプロイを終了します。したがって、現在の本番稼働フリートで既にエラーが発生している場合は、次の例のいずれかを使用または変更して、新しいフリートのエラーのみをモニタリングすることを検討してください。
```
#Applied deployment type: all types
{
"AlarmName": "EndToEndDeploymentHighErrorRateAlarm",
"AlarmDescription": "Monitors the error rate of 4xx errors",
"MetricName": "Invocation4XXErrors",
"Namespace": "AWS/SageMaker",
"Statistic": "Average",
"Dimensions": [
{
"Name": "EndpointName",
"Value":
},
{
"Name": "VariantName",
"Value": "AllTraffic"
}
],
"Period": 600,
"EvaluationPeriods": 2,
"Threshold": 1,
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
```
前の例では、次のフィールドの値に注意してください。
+ `AlarmName` と `AlarmDescription` には、アラームの名前と説明を入力します。
+ `MetricName` には、値 `Invocation4XXErrors` を使用して、エンドポイントで 4xx エラーをモニタリングします
+ `Namespace` には、値 `AWS/SageMaker` を使用します。必要に応じて、独自のカスタムメトリクスを指定することもできます。
+ `Statistic` の場合は、`Average` を使用します。これは、エラー率がしきい値を超えたかどうかを計算するときに、アラームが評価期間中の平均エラー率を取得することを意味します。
+ ディメンション `EndpointName` には、更新するエンドポイントの名前を値として使用します。
+ ディメンション `VariantName` には、値 `AllTraffic` を使用して、すべてのエンドポイントトラフィックを指定します。
+ `Period` の場合は、`600` を使用します。これにより、アラームの評価期間が 10 分に設定されます。
+ `EvaluationPeriods` の場合は、`2` を使用します。この値は、アラームステータスを決定する際に、直近の 2 つの評価期間を考慮するようにアラームに指示します。
### 新しいフリートのモデルのレイテンシーをモニタリングする
次の CloudWatch アラームの例は、デプロイ中の新しいフリートのモデルのレイテンシーをモニタリングします。このアラームを使って、新しいフリートのみをモニタリングし、古いフリートを除外できます。アラームは、デプロイ全体で持続します。この例では、新しいフリートの包括的なエンドツーエンドのモニタリングを行い、新しいフリートに応答時間の問題がある場合、古いフリートへのロールバックを開始します。
CloudWatch は、新しいフリートがトラフィックを受信し始めた後、ディメンション `EndpointConfigName:{New-Ep-Config}` を含むメトリクスを発行します。これらのメトリクスはデプロイが完了した後も持続します。
次のアラーム例は、どのデプロイタイプでも使用できます。
```
#Applied deployment type: all types
{
"AlarmName": "NewEndpointConfigVersionHighModelLatencyAlarm",
"AlarmDescription": "Monitors the model latency on new fleet",
"MetricName": "ModelLatency",
"Namespace": "AWS/SageMaker",
"Statistic": "Average",
"Dimensions": [
{
"Name": "EndpointName",
"Value":
},
{
"Name": "VariantName",
"Value": "AllTraffic"
},
{
"Name": "EndpointConfigName",
"Value":
],
"Period": 300,
"EvaluationPeriods": 2,
"Threshold": 100000, # 100ms
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
```
前の例では、次のフィールドの値に注意してください。
+ `MetricName` には、値 `ModelLatency` を使用して、モデルの応答時間をモニタリングします。
+ `Namespace` には、値 `AWS/SageMaker` を使用します。必要に応じて、独自のカスタムメトリクスを指定することもできます。
+ ディメンション `EndpointName` には、更新するエンドポイントの名前を値として使用します。
+ ディメンション `VariantName` には、値 `AllTraffic` を使用して、すべてのエンドポイントトラフィックを指定します。
+ ディメンション `EndpointConfigName` については、値は、新規または更新されたエンドポイントのエンドポイント設定名を参照します。
**注記**
新しいフリートではなく古いフリートをモニタリングする場合は、ディメンション `EndpointConfigName` を、古いフリートの設定名を指定するように変更できます。
# ブルー/グリーンデプロイ
エンドポイントを更新するとき、Amazon SageMaker AI は自動的にブルー/グリーンデプロイを使って、エンドポイントの可用性を最大化します。ブルー/グリーンデプロイでは、SageMaker AI は更新された新しいフリート (緑のフリート) をプロビジョニングします。その後、SageMaker AI は古いフリート (青のフリート) から緑のフリートにトラフィックをシフトします。緑のフリートが所定の評価期間 (ベーキング期間と呼ばれる) スムーズに動作すると、SageMaker AI は青のフリートを終了します。Blue/Green デプロイの追加機能により、トラフィックシフトモードと自動ロールバックモニタリングを利用して、本番環境への重大な影響からエンドポイントを保護できます。
以下に、SageMaker AI のブルー/グリーンデプロイの主な機能について説明します。
+ **トラフィックシフトモード。**デプロイガードレールのトラフィックシフトモードにより、青のフリートと緑のフリートの間のトラフィック量とトラフィックシフトステップ数をコントロールできます。この機能により、100% のトラフィックシフトを完全にコミットすることなく、緑のフリートのパフォーマンスを段階的に評価できます。
+ **ベーキング期間。**ベーキング期間とは、次のデプロイ段階に進む前に緑のフリートをモニタリングするための一定時間です。どのベーキング期間中でも、事前に指定したアラームのいずれかが作動した場合、すべてのエンドポイントトラフィックは青のフリートにロールバックされます。ベーキング期間は、トラフィックシフトを永続的なものにする前に、更新の信頼を構築するのに役立ちます。
+ **自動ロールバック。**SageMaker AI が緑のフリートのモニタリングに使う Amazon CloudWatch アラームを指定できます。更新されたコードの問題によってアラームが作動した場合、SageMaker AI は可用性維持のために青のフリートへの自動ロールバックを開始し、リスクを最小限に抑えます。
## トラフィックシフトモード
Blue/Green デプロイのさまざまなトラフィックシフトモードを使うと、青のフリートと緑のフリート間のトラフィックシフトをより詳細にコントロールできます。Blue/Green デプロイで使用可能なトラフィックシフトモードは、All at Once、Canary、Linear です。次の表に、オプションの比較を示します。
**重要**
複数ステージのトラフィックシフトまたはベーキング期間を含む Blue/Green デプロイの場合、フリートへのトラフィックに関係なく、更新期間中は両方のフリートに対して課金されます。これは、All at Once トラフィックシフトでベーキング期間がない Blue/Green デプロイとは対照的です。その場合は、更新の過程で 1 つのフリートに対してのみ課金されます。
| 名前 | 説明 | 長所 | 短所 | 推奨事項 |
| --- | --- | --- | --- | --- |
| All at once | すべてのトラフィックを 1 つのステップで新しいフリートにシフトします。 | 全体の更新時間を最小限に抑えます。 | 後退的更新は、100% のトラフィックに影響を与えます。 | このオプションを使って、更新時間とコストを最小限に抑えます。 |
| Canary | 2 つのステップでトラフィックをシフトします。最初の (canary) ステップでトラフィックのごく一部を移行し、次に 2 番目のステップで残りのトラフィックをシフトします。 | 後退的更新の影響範囲を Canary フリートのみに制限します。 | 両方のフリートは、デプロイ全体で並行して動作します。 | このオプションを使って、後退的更新の影響範囲を最小化することと、2 つのフリートが動作している時間を最小化することのバランスを取ります。 |
| [線形] | トラフィックの固定部分を、事前に指定した数の等間隔のステップでシフトします。 | 複数のステップでトラフィックをシフトすることで、後退的更新のリスクを最小限に抑えます。 | 更新時間とコストはステップ数に比例します。 | このオプションを使って、デプロイを複数のステップに分散させてリスクを最小限に抑えます。 |
## 使用を開始する
デプロイ設定が指定されると、SageMaker AI は新しいインスタンスのプロビジョニング、古いインスタンスの終了、トラフィックのシフトを行います。既存の [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) と [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) SageMaker API、および AWS Command Line Interface コマンドを使用して、デプロイを作成、管理できます。エンドポイントが「[Exclusions](deployment-guardrails-exclusions.md)」ページにリストされているいずれかの機能を使っている場合、デプロイガードレールは使用できないことに注意してください。デプロイの設定方法の詳細については、個々のデプロイページを参照してください。
+ [All At Once トラフィック移行による Blue/Green 更新](deployment-guardrails-blue-green-all-at-once.md)
+ [Canary トラフィック移行による Blue/Green 更新](deployment-guardrails-blue-green-canary.md)
+ [Linear トラフィック移行による Blue/Green 更新](deployment-guardrails-blue-green-linear.md)
デプロイガードレールの使用方法を示すガイド付きの例に従うには、Canary および Linear トラフィックシフトモードの[Jupyter ノートブック](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-inference-deployment-guardrails)の例を参照してください。
# All At Once トラフィックシフトを使用する
All At Once トラフィックシフトにより、Blue/Green デプロイの安全なガードレールを使って、エンドポイントの更新を迅速にロールアウトできます。このトラフィックシフトオプションを使うと、Blue/Green デプロイの可用性の保証を利用しながら、更新時間を最小限に抑えることができます。ベーキング期間機能は、古いインスタンスを終了する前に新しいインスタンスのパフォーマンスと機能をモニタリングし、新しいフリートが完全に動作可能かを確認するのに役立ちます。
次の図は、All At Once トラフィックシフトが古いフリートと新しいフリートを管理する方法を示しています。
![\[古いフリートから新しいフリートへの 100% のトラフィックシフトに成功。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/deployment-guardrails-blue-green-all-at-once.png)
All At Once トラフィックシフトを使うと、SageMaker AI は 100% のトラフィックを新しいフリート (緑のフリート) にルーティングします。緑のフリートがトラフィックを受信し始めると、ベーキング期間が始まります。ベーキング期間は、事前に指定した Amazon CloudWatch アラームが緑のフリートのパフォーマンスをモニタリングする一定期間です。ベーキング期間中にアラームが作動しない場合、SageMaker AI は古いフリート (青のフリート) を終了します。ベーキング期間中にアラームが作動した場合は、自動ロールバックが開始され、100% のトラフィックが青のフリートに戻ります。
## 前提条件
All At Once トラフィックシフトを使うデプロイを設定する前に、エンドポイントからのメトリクスをモニタリングする Amazon CloudWatch アラームを作成する必要があります。ベーキング期間中にアラームが作動した場合、トラフィックは青のフリートにロールバックされます。エンドポイントに CloudWatch アラームを設定する方法については、前提条件のページ「[設定とモニタリングを自動ロールバックする](deployment-guardrails-configuration.md)」を参照してください。CloudWatch アラームの詳細については、[Amazon CloudWatch ユーザーガイド](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)の「*Amazon CloudWatch でのアラームの使用*」を参照してください。
## All At Once トラフィックシフトを設定する
デプロイの準備が整い、エンドポイントに CloudWatch アラームを設定したら、SageMaker AI [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API または AWS Command Line Interface の [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) コマンドのいずれかを使って、デプロイを開始できます。
**Topics**
+ [エンドポイントを更新する方法 (API)](#deployment-guardrails-blue-green-all-at-once-configure-api-update)
+ [既存の Blue/Green 更新ポリシーでエンドポイントを更新する方法 (API)](#deployment-guardrails-blue-green-all-at-once-configure-api-existing)
+ [エンドポイントを更新する方法 (CLI)](#deployment-guardrails-blue-green-all-at-once-configure-cli-update)
### エンドポイントを更新する方法 (API)
次の例は、Amazon SageMaker API の [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) を使って、All At Once トラフィックシフトでエンドポイントを更新する方法を示しています。
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "ALL_AT_ONCE"
},
"TerminationWaitInSeconds": 600,
"MaximumExecutionTimeoutInSeconds": 1800
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
},
]
}
}
)
```
All At Once トラフィックシフトオプションを設定するには、以下を実行します。
+ `EndpointName` には、更新する既存のエンドポイントの名前を使用します。
+ `EndpointConfigName` には、使用するエンドポイント設定の名前を使用します。
+ `DeploymentConfig` と `BlueGreenUpdatePolicy` の下の `TrafficRoutingConfiguration` で、`Type` パラメータを `ALL_AT_ONCE` に設定します。これは、デプロイが All At Once トラフィックシフトモードを使うよう指定します。
+ `TerminationWaitInSeconds` の場合は、`600` を使用します。このパラメータは SageMaker AI に対し、緑のフリートが完全にアクティブになった後、青のフリートのインスタンスを終了するまで、所定の時間 (秒単位) 待機するよう指示します。この例では、SageMaker AI は最後のベーキング期間後 10 分間待機してから、青のフリートを終了します。
+ `MaximumExecutionTimeoutInSeconds` の場合は、`1800` を使用します。このパラメータは、デプロイがタイムアウトするまでに実行できる最大時間を設定します。前の例では、デプロイが終了するまでの制限時間は 30 分です。
+ `AutoRollbackConfiguration` の `Alarms` フィールドでは、CloudWatch アラームを名前で追加できます。使うアラームごとに 1 つの `AlarmName: ` エントリを作成します。
### 既存の Blue/Green 更新ポリシーでエンドポイントを更新する方法 (API)
[CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) API を使ってエンドポイントを作成する場合は、必要に応じて、将来のエンドポイントの更新に再利用するデプロイ設定を指定できます。前の UpdateEndpoint API の例と同じ `DeploymentConfig` オプションを使用できます。CreateEndpoint API の動作に変化はありません。デプロイ設定を指定しても、エンドポイントでの Blue/Green 更新が自動的に実行されるわけではありません。
以前のデプロイ設定を使うオプションは、[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API エンドポイントを使ってエンドポイントを更新するときに発生します。エンドポイントを更新するときは、`RetainDeploymentConfig` オプションを使って、エンドポイントの作成時に指定したデプロイ設定を保持できます。
[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API を呼び出すときに、`RetainDeploymentConfig` を `True` に設定して、元のエンドポイント設定の `DeploymentConfig` オプションを保持します。
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### エンドポイントを更新する方法 (CLI)
AWS CLI を使う場合、次の例は、[update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) コマンドを使って Blue/Green All At Once デプロイメントを始める方法を示しています。
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "ALL_AT_ONCE"},
"TerminationWaitInSeconds": 600, "MaximumExecutionTimeoutInSeconds": 1800},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
All At Once トラフィックシフトオプションを設定するには、以下を実行します。
+ `endpoint-name` には、更新するエンドポイントの名前を使用します。
+ `endpoint-config-name` には、使用するエンドポイント設定の名前を使用します。
+ `deployment-config` には、[BlueGreenUpdatePolicy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html) JSON オブジェクトを使用します。
**注記**
JSON オブジェクトをファイルに保存する場合は、*AWS CLI ユーザーガイド*の「[AWS CLI スケルトンと入力パラメータの生成](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html)」を参照してください。
# Canary トラフィックシフトを使用する
Canary トラフィックシフトにより、エンドポイントトラフィックの一部を新しいフリートでテストしながら、残りのトラフィックを古いフリートで処理できます。このテストステップは、すべてのトラフィックを新しいフリートにシフトする前に、新しいフリートの機能を検証する安全なガードレールです。Blue/Green デプロイの利点はそのままで、加わる Canary 機能により、新しい (緑の) フリートで 100% のトラフィックを処理する前に、推論を提供できるようになります。
トラフィックを受信するためにオンになる緑のフリートの部分は canary と呼ばれ、この canary のサイズを選択できます。canary のサイズは、新しいフリートの容量の 50% 以下になるように注意してください。ベーキング期間が終了し、事前に指定した Amazon CloudWatch アラームの作動がなければ、残りのトラフィックは古い (青の) フリートから緑のフリートにシフトします。Canary トラフィックシフトは、更新されたモデルに関する問題が canary にのみ影響するため、デプロイ時の安全性が向上します。
次の図は、Canary トラフィックシフトが青と緑のフリート間のトラフィックの分散を管理する方法を示しています。
![\[古いフリートから新しいフリートへの 2 ステップの Canary トラフィックシフトに成功。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/deployment-guardrails-blue-green-canary.png)
SageMaker AI が緑のフリートをプロビジョンすると、SageMaker AI は着信トラフィックの一部 (25% など) を canary にルーティングします。その後、ベーキング期間が始まり、その間は CloudWatch アラームが緑のフリートのパフォーマンスをモニタリングします。この間、青のフリートと緑のフリートの両方が部分的にアクティブになり、トラフィックを受信します。ベーキング期間中にいずれかのアラームが作動した場合、SageMaker AI はロールバックを開始し、すべてのトラフィックが青のフリートに戻ります。いずれのアラームも作動しない場合は、すべてのトラフィックが緑のフリートにシフトし、最後のベーキング期間があります。アラームが作動せずに最後のベーキング期間が終了すると、緑のフリートがすべてのトラフィックを処理し、SageMaker AI は青のフリートを終了します。
## 前提条件
Canary トラフィックシフトを使うデプロイを設定する前に、エンドポイントからのメトリクスをモニタリングするよう Amazon CloudWatch アラームを作成する必要があります。アラームはベーキング期間中アクティブになり、いずれかのアラームが作動した場合、すべてのエンドポイントトラフィックは青のフリートにロールバックされます。エンドポイントに CloudWatch アラームを設定する方法については、前提条件のページ「[設定とモニタリングを自動ロールバックする](deployment-guardrails-configuration.md)」を参照してください。CloudWatch アラームの詳細については、[Amazon CloudWatch ユーザーガイド](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)の「*Amazon CloudWatch でのアラームの使用*」を参照してください。
## Canary トラフィックシフトを設定する
デプロイの準備が整い、エンドポイントに Amazon CloudWatch アラームを設定したら、Amazon SageMaker AI [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API または AWS CLI の [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) コマンドのいずれかを使って、デプロイを開始できます。
**Topics**
+ [エンドポイントを更新する方法 (API)](#deployment-guardrails-blue-green-canary-configure-api-update)
+ [既存の Blue/Green 更新ポリシーでエンドポイントを更新する方法 (API)](#deployment-guardrails-blue-green-canary-configure-api-existing)
+ [エンドポイントを更新する方法 (CLI)](#deployment-guardrails-blue-green-canary-configure-cli-update)
### エンドポイントを更新する方法 (API)
次の [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API の例は、Canary トラフィックシフトでエンドポイントを更新する方法を示しています。
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "CANARY",
"CanarySize": {
"Type": "CAPACITY_PERCENT",
"Value": 30
},
"WaitIntervalInSeconds": 600
},
"TerminationWaitInSeconds": 600,
"MaximumExecutionTimeoutInSeconds": 1800
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
}
]
}
}
)
```
Canary トラフィックシフトオプションを設定するには、以下を実行します。
+ `EndpointName` には、更新する既存のエンドポイントの名前を使用します。
+ `EndpointConfigName` には、使用するエンドポイント設定の名前を使用します。
+ `DeploymentConfig` と `BlueGreenUpdatePolicy` の下の `TrafficRoutingConfiguration` で、`Type` パラメータを `CANARY` に設定します。これは、デプロイが Canary トラフィックシフトを使うよう指定します。
+ `CanarySize` フィールドでは、`Type` と `Value` パラメータを変更することで canary のサイズを変更できます。`Type` には、`CAPACITY_PERCENT` を使用します。これは、canary として使う緑のフリートの割合を意味し、`30` には `Value` を設定します。この例では、緑のフリートの容量の 30% を canary として使用します。canary のサイズは、緑のフリートの容量の 50% 以下になるように注意してください。
+ `WaitIntervalInSeconds` の場合は、`600` を使用します。このパラメータは、間隔シフト間で所定の時間 (秒単位) 待機するよう SageMaker AI に指示します。この間隔は、canary ベーキング期間の長さです。前の例では、SageMaker AI は canary シフト後 10 分間待機してから、2 番目と最後のトラフィックシフトを完了します。
+ `TerminationWaitInSeconds` の場合は、`600` を使用します。このパラメータは SageMaker AI に対し、緑のフリートが完全にアクティブになった後、青のフリートのインスタンスを終了するまで、所定の時間 (秒単位) 待機するよう指示します。この例では、SageMaker AI は最後のベーキング期間後 10 分間待機してから、青のフリートを終了します。
+ `MaximumExecutionTimeoutInSeconds` の場合は、`1800` を使用します。このパラメータは、デプロイがタイムアウトするまでに実行できる最大時間を設定します。前の例では、デプロイが終了するまでの制限時間は 30 分です。
+ `AutoRollbackConfiguration` の `Alarms` フィールドでは、CloudWatch アラームを名前で追加できます。使うアラームごとに 1 つの `AlarmName: ` エントリを作成します。
### 既存の Blue/Green 更新ポリシーでエンドポイントを更新する方法 (API)
[CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) API を使ってエンドポイントを作成する場合は、必要に応じて、将来のエンドポイントの更新に再利用するデプロイ設定を指定できます。前の UpdateEndpoint API の例と同じ `DeploymentConfig` オプションを使用できます。CreateEndpoint API の動作に変化はありません。デプロイ設定を指定しても、エンドポイントでの Blue/Green 更新が自動的に実行されるわけではありません。
以前のデプロイ設定を使うオプションは、[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API エンドポイントを使ってエンドポイントを更新するときに発生します。エンドポイントを更新するときは、`RetainDeploymentConfig` オプションを使って、エンドポイントの作成時に指定したデプロイ設定を保持できます。
[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API を呼び出すときに、`RetainDeploymentConfig` を `True` に設定して、元のエンドポイント設定の `DeploymentConfig` オプションを保持します。
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### エンドポイントを更新する方法 (CLI)
AWS CLI を使う場合、次の例は、[update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) コマンドを使って Blue/Green canary デプロイメントを始める方法を示しています。
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "CANARY",
"CanarySize": {"Type": "CAPACITY_PERCENT", "Value": 30}, "WaitIntervalInSeconds": 600},
"TerminationWaitInSeconds": 600, "MaximumExecutionTimeoutInSeconds": 1800},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Canary トラフィックシフトオプションを設定するには、以下を実行します。
+ `endpoint-name` には、更新するエンドポイントの名前を使用します。
+ `endpoint-config-name` には、使用するエンドポイント設定の名前を使用します。
+ `deployment-config` には、[BlueGreenUpdatePolicy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html) JSON オブジェクトを使用します。
**注記**
JSON オブジェクトをファイルに保存する場合は、*AWS CLI ユーザーガイド*の「[AWS CLI スケルトンと入力パラメータの生成](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html)」を参照してください。
# Linear トラフィックシフトを使用する
Linear トラフィックシフトは、古いフリート (青のフリート) から新しいフリート (緑のフリート) に徐々にトラフィックをシフトさせることができます。Linear トラフィックシフトにより、複数のステップでトラフィックをシフトできるため、エンドポイントで障害が発生する可能性を最小限に抑えることができます。この Blue/Green デプロイオプションでは、トラフィックシフトを最も細かくコントロールできます。
各ステップでアクティブ化するインスタンス数または緑のフリートの容量の割合のいずれかを選択できます。各 Linear ステップは、緑のフリートの容量の 10～50% の間にしてください。ステップごとに、事前に指定した Amazon CloudWatch アラームが緑のフリートのメトリクスをモニタリングするベーキング期間があります。ベーキング期間が終了し、アラームの作動がなければ、緑のフリートのアクティブな部分は引き続きトラフィックを受信し、新しいステップが始まります。ベーキング期間中にアラームが作動した場合、100% のエンドポイントトラフィックは青のフリートにロールバックされます。
次の図は、Linear トラフィックシフトがトラフィックを青と緑のフリートにルーティングする方法を示しています。
![\[3 段階で古いフリートから新しいフリートへの Linear トラフィックシフトが完了。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/deployment-guardrails-blue-green-linear.png)
SageMaker AI が新しいフリートをプロビジョニングすると、緑のフリートの最初の部分がオンになり、トラフィックを受信します。SageMaker AI は青のフリートの同じサイズの部分を非アクティブ化し、ベーキング期間が始まります。アラームが作動した場合、すべてのエンドポイントトラフィックは青のフリートにロールバックされます。ベーキング期間が終了すると、次のステップが始まります。緑のフリートの別の部分がアクティブ化されてトラフィックを受信し、青のフリートの一部が非アクティブ化され、別のベーキング期間が始まります。青のフリートが完全に非アクティブ化され、緑のフリートが完全にアクティブ化され、すべてのトラフィックを受信するまで、同じプロセスが繰り返されます。いずれかの時点でアラームが作動すると、SageMaker AI はシフトプロセスを終了し、100% のトラフィックが青のフリートにロールバックされます。
## 前提条件
Linear トラフィックシフトを使うデプロイを設定する前に、エンドポイントからのメトリクスをモニタリングする CloudWatch アラームを作成する必要があります。アラームはベーキング期間中アクティブになり、いずれかのアラームが作動した場合、すべてのエンドポイントトラフィックは青のフリートにロールバックされます。エンドポイントに CloudWatch アラームを設定する方法については、前提条件のページ「[設定とモニタリングを自動ロールバックする](deployment-guardrails-configuration.md)」を参照してください。CloudWatch アラームの詳細については、[Amazon CloudWatch ユーザーガイド](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)の「*Amazon CloudWatch でのアラームの使用*」を参照してください。
## Linear トラフィックシフトを設定する
デプロイの準備が整い、エンドポイントに CloudWatch アラームを設定したら、Amazon SageMaker AI [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API または AWS CLI の [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) コマンドのいずれかを使って、デプロイを開始できます。
**Topics**
+ [エンドポイントを更新する方法 (API)](#deployment-guardrails-blue-green-linear-configure-api-update)
+ [既存の Blue/Green 更新ポリシーでエンドポイントを更新する方法 (API)](#deployment-guardrails-blue-green-linear-configure-api-existing)
+ [エンドポイントを更新する方法 (CLI)](#deployment-guardrails-blue-green-canary-configure-cli-update)
### エンドポイントを更新する方法 (API)
次の [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API の例は、Linear トラフィックシフトでエンドポイントを更新する方法を示しています。
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"BlueGreenUpdatePolicy": {
"TrafficRoutingConfiguration": {
"Type": "LINEAR",
"LinearStepSize": {
"Type": "CAPACITY_PERCENT",
"Value": 20
},
"WaitIntervalInSeconds": 300
},
"TerminationWaitInSeconds": 300,
"MaximumExecutionTimeoutInSeconds": 3600
},
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
}
]
}
}
)
```
Linear トラフィックシフトオプションを設定するには、以下を実行します。
+ `EndpointName` には、更新する既存のエンドポイントの名前を使用します。
+ `EndpointConfigName` には、使用するエンドポイント設定の名前を使用します。
+ `DeploymentConfig` と `BlueGreenUpdatePolicy` の下の `TrafficRoutingConfiguration` で、`Type` パラメータを `LINEAR` に設定します。これは、デプロイが Linear トラフィックシフトを使うよう指定します。
+ `LinearStepSize` フィールドでは、`Type` と `Value` パラメータを変更することでステップのサイズを変更できます。`Type` には、`CAPACITY_PERCENT` を使用します。これは、ステップサイズとして使う緑のフリートの割合を意味し、`Value` には `20` を設定します。この例では、トラフィックシフトステップごとに緑のフリートの容量の 20% をオンにします。Linear ステップサイズをカスタマイズする場合、緑のフリートの容量の 10～50% のステップのみを使うよう注意してください。
+ `WaitIntervalInSeconds` の場合は、`300` を使用します。このパラメータは、トラフィックシフト間で所定の時間 (秒単位) 待機するように SageMaker AI に指示します。この間隔は、各 Linear ステップ間のベーキング期間の長さです。前の例では、SageMaker AI は各トラフィックシフト間で 5 分間待機します。
+ `TerminationWaitInSeconds` の場合は、`300` を使用します。このパラメータは SageMaker AI に対し、緑のフリートが完全にアクティブになった後、青のフリートのインスタンスを終了するまで、所定の時間 (秒単位) 待機するよう指示します。この例では、SageMaker AI は最後のベーキング期間後 5 分間待機してから、青のフリートを終了します。
+ `MaximumExecutionTimeoutInSeconds` の場合は、`3600` を使用します。このパラメータは、デプロイがタイムアウトするまでに実行できる最大時間を設定します。前の例では、デプロイが終了するまでの制限時間は 1 時間です。
+ `AutoRollbackConfiguration` の `Alarms` フィールドでは、CloudWatch アラームを名前で追加できます。使うアラームごとに 1 つの `AlarmName: ` エントリを作成します。
### 既存の Blue/Green 更新ポリシーでエンドポイントを更新する方法 (API)
[CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) API を使ってエンドポイントを作成する場合は、必要に応じて、将来のエンドポイントの更新に再利用するデプロイ設定を指定できます。前の UpdateEndpoint API の例と同じ `DeploymentConfig` オプションを使用できます。CreateEndpoint API の動作に変化はありません。デプロイ設定を指定しても、エンドポイントでの Blue/Green 更新が自動的に実行されるわけではありません。
以前のデプロイ設定を使うオプションは、[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API エンドポイントを使ってエンドポイントを更新するときに発生します。エンドポイントを更新するときは、`RetainDeploymentConfig` オプションを使って、エンドポイントの作成時に指定したデプロイ設定を保持できます。
[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API を呼び出すときに、`RetainDeploymentConfig` を `True` に設定して、元のエンドポイント設定の `DeploymentConfig` オプションを保持します。
```
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
RetainDeploymentConfig=True
)
```
### エンドポイントを更新する方法 (CLI)
AWS CLI を使う場合、次の例は、[update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) コマンドを使って Blue/Green Linear デプロイメントを始める方法を示しています。
```
update-endpoint
--endpoint-name
--endpoint-config-name
--deployment-config '{"BlueGreenUpdatePolicy": {"TrafficRoutingConfiguration": {"Type": "LINEAR",
"LinearStepSize": {"Type": "CAPACITY_PERCENT", "Value": 20}, "WaitIntervalInSeconds": 300},
"TerminationWaitInSeconds": 300, "MaximumExecutionTimeoutInSeconds": 3600},
"AutoRollbackConfiguration": {"Alarms": [{"AlarmName": ""}]}'
```
Linear トラフィックシフトオプションを設定するには、以下を実行します。
+ `endpoint-name` には、更新するエンドポイントの名前を使用します。
+ `endpoint-config-name` には、使用するエンドポイント設定の名前を使用します。
+ `deployment-config` には、[BlueGreenUpdatePolicy](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_BlueGreenUpdatePolicy.html) JSON オブジェクトを使用します。
**注記**
JSON オブジェクトをファイルに保存する場合は、*AWS CLI ユーザーガイド*の「[AWS CLI スケルトンと入力パラメータの生成](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html)」を参照してください。
# ローリングデプロイを使用する
エンドポイントを更新するときに、ローリングデプロイを指定して、トラフィックを古いフリートから新しいフリートに徐々に移行することができます。評価期間を指定して古いフリートのインスタンスを終了する前に新しいインスタンスに問題がないか監視できるだけでなく、移行トラフィックのステップのサイズも制御できます。ローリングデプロイでは、各トラフィックが新しいフリートに移行された後、古いフリートのインスタンスがクリーンアップされるので、エンドポイントの更新に必要な追加インスタンスの量が減ります。これは、高需要の高速化されたインスタンスで特に役立ちます。
ローリングデプロイでは、設定可能なバッチサイズでエンドポイントを更新することにより、モデルの以前のバージョンのデプロイを新しいバージョンに徐々に置き換えます。ローリングデプロイのトラフィックの移行動作はブルー/グリーンデプロイの[線形トラフィック移行モード](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-blue-green-linear.html)に似ていますが、ブルー/グリーンデプロイと比較し、ローリングデプロイにはキャパシティ要件が削減されるというメリットがあります。ローリングデプロイでは、一度にアクティブになるインスタンスが少なくなり、新しいフリートで更新するインスタンスの数をきめ細かく制御できます。大規模モデルや多くのインスタンスを持つ大規模エンドポイントを使用している場合は、ブルー/グリーンデプロイの代わりにローリングデプロイの使用を検討する必要があります。
次のリストで、Amazon SageMaker AI の ローリングデプロイの主な機能について説明します:
+ **ベーキング期間。**ベーキング期間とは、次のデプロイステージに進む前に新しいフリートを監視する一定の時間のことです。どのベーキング期間中においても、事前に指定したアラームのいずれかが作動した場合、すべてのエンドポイントトラフィックは古いフリートにロールバックされます。ベーキング期間は、トラフィックシフトを永続的なものにする前に、更新の信頼を構築するのに役立ちます。
+ **ローリングのバッチサイズ。**トラフィック移行のための各バッチサイズ、または各バッチで更新するインスタンスの数をきめ細かく制御できます。この数値は、フリートのサイズの 5～50% の範囲で設定できます。バッチサイズは、インスタンス数、またはフリート全体の割合として指定できます。
+ **自動ロールバック。**SageMaker AI が新しいフリートの監視に使用する Amazon CloudWatch アラームを指定できます。更新されたコードの問題によってアラームが作動した場合、SageMaker AI は可用性を維持するために古いフリートへの自動ロールバックを開始し、リスクを最小限に抑えます。
**注記**
エンドポイントが [[除外事項]](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-exclusions.html) ページに一覧表示されているいずれかの機能を使用している場合、ローリングデプロイは使用できません。
## 仕組み
ローリングデプロイ中、SageMaker AI は、すべての新しいインスタンスを一度にプロビジョニングすることなく古いフリートから新しいフリートにトラフィックを移行するためのインフラストラクチャを提供します。SageMaker AI は次の手順を使用してトラフィックを移行します。
1. SageMaker AI は、新しいフリートのインスタンスの最初のバッチをプロビジョニングします。
1. トラフィックの一部は、古いインスタンスから新しいインスタンスの最初のバッチに移行されます。
1. ベーキング期間の後、Amazon CloudWatch アラームが作動しなければ、SageMaker AI は古いインスタンスのバッチをクリーンアップします。
1. SageMaker AI は、デプロイが完了するまで、バッチのインスタンスのプロビジョニング、移行、およびクリーンアップを継続します。
いずれかのベーキング期間中にアラームが作動すると、トラフィックは指定したサイズのバッチで古いフリートにロールバックされます。また、ローリングデプロイを指定し、アラームが作動した場合にトラフィックの 100% を古いフリートに戻すこともできます。
次の図は、前のステップで説明したように、ローリングデプロイが成功する場合の進行状況を示しています。
![\[ローリングデプロイにおいて古いフリートから新しいフリートにトラフィックを正常に移行する手順。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/deployment-guardrails-rolling-diagram.png)
目的のデプロイ構成を指定するだけでローリングデプロイを作成できます。その後、SageMaker AI は新しいインスタンスのプロビジョニング、古いインスタンスの終了、トラフィックの移行を行います。デプロイを作成および管理するには、既存の [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) および [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html) SageMaker API と AWS Command Line Interface コマンドを使用します。
## 前提条件
ローリングデプロイを設定する前に、エンドポイントからのメトリクスを監視する Amazon CloudWatch アラームを作成する必要があります。ベーキング期間中にアラームが作動した場合、トラフィックは古いフリートにロールバックされます。エンドポイントに CloudWatch アラームを設定する方法については、前提条件のページの「Auto-Rollback Configuration and Monitoring」を参照してください。CloudWatch アラームの詳細については、[Amazon CloudWatch ユーザーガイド](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html)の「*Amazon CloudWatch でのアラームの使用*」を参照してください。
また、[[除外事項]](https://docs.aws.amazon.com/sagemaker/latest/dg/deployment-guardrails-exclusions.html) ページを確認して、エンドポイントがローリングデプロイの要件を満たしていることを確認してください。
## ローリングのバッチサイズを決定する
エンドポイントを更新する前に、新しいフリートにトラフィックを段階的に移行するのに使用するバッチサイズを決定します。
ローリングデプロイでは、バッチサイズにフリートの容量の 5～50% を指定できます。大きいバッチサイズを選択すると、デプロイはより短時間で完了します。ただし、エンドポイントが更新中に必要とする容量は、バッチサイズのオーバーヘッドとほぼ同じであることに注意してください。小さいバッチサイズを選択した場合、デプロイには時間がかかりますが、デプロイ中に使用する容量は少なくなります。
## ローリングデプロイを設定する
デプロイの準備ができ、エンドポイントに CloudWatch アラームを設定したら、SageMaker AI [UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API または の [update-endpoint](https://docs.aws.amazon.com/cli/latest/reference/sagemaker/update-endpoint.html) コマンドを使用してデプロイ AWS Command Line Interface を開始できます。
エンドポイントを更新する方法
次の例は、Boto3 SageMaker AI クライアントの [update\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/update_endpoint.html) メソッドを使用し、ローリングデプロイでエンドポイントを更新する方法を示しています。
ローリングデプロイを設定するには、次の例とフィールドを使用します。
+ `EndpointName` には、更新する既存のエンドポイントの名前を使用します。
+ `EndpointConfigName` には、使用するエンドポイント設定の名前を使用します。
+ `AutoRollbackConfiguration` オブジェクトの `Alarms` フィールドに、CloudWatch アラームを名前で追加できます。使うアラームごとに 1 つの `AlarmName: ` エントリを作成します。
+ `DeploymentConfig` で、`RollingUpdatePolicy` オブジェクトに次のフィールドを指定します。
+ `MaximumExecutionTimeoutInSeconds` — デプロイの合計制限時間。この制限を超えるとタイムアウトになります。このフィールドに指定できる最大値は 28800 秒、つまり 8 時間です。
+ `WaitIntervalInSeconds` — SageMaker AI が新しいフリートの各バッチのアラームを監視するベーキング期間の長さ。
+ `MaximumBatchSize` — 使用するバッチの `Type` (インスタンス数またはフリート全体に対する割合) と `Value`、または各バッチのサイズを指定します。
+ `RollbackMaximumBatchSize` — このオブジェクトを使用して、アラームが作動した場合のロールバック戦略を指定します。使用するバッチの `Type` (インスタンス数またはフリート全体に対する割合) と `Value`、または各バッチのサイズを指定します。これらのフィールドを指定しない場合、または値をエンドポイントの 100% に設定した場合、SageMaker AI はブルー/グリーンロールバック戦略を使用し、アラームの作動時にすべてのトラフィックを古いフリートにロールバックします。
```
import boto3
client = boto3.client("sagemaker")
response = client.update_endpoint(
EndpointName="",
EndpointConfigName="",
DeploymentConfig={
"AutoRollbackConfiguration": {
"Alarms": [
{
"AlarmName": ""
},
]
},
"RollingUpdatePolicy": {
"MaximumExecutionTimeoutInSeconds": number,
"WaitIntervalInSeconds": number,
"MaximumBatchSize": {
"Type": "INSTANCE_COUNT" | "CAPACITY_PERCENTAGE" (default),
"Value": number
},
"RollbackMaximumBatchSize": {
"Type": "INSTANCE_COUNT" | "CAPACITY_PERCENTAGE" (default),
"Value": number
},
}
}
)
```
エンドポイントを更新した後、ローリングデプロイのステータスやエンドポイントの正常性を確認したい場合があります。SageMaker AI コンソールでエンドポイントのステータスを確認することも、[DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) API を使用してエンドポイントのステータスを確認することもできます。
`DescribeEndpoint` API によって返される `VariantStatus` オブジェクトの `Status`フィールドで、エンドポイントの現在のデプロイまたは動作状況がわかります。有効なステータスとその意味に関する詳細については、「[ProductionVariantStatus](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariantStatus.html)」を参照してください。
ローリングデプロイを試み、エンドポイントのステータスが `UpdateRollbackFailed` の場合、トラブルシューティングヘルプについて次のセクションを参照してください。
## 障害処理
ローリングデプロイが失敗し、自動ロールバックも同様の場合、エンドポイントのステータスは `UpdateRollbackFailed` のままです。このステータスは、エンドポイントの背後にあるインスタンスに異なるエンドポイント設定がデプロイされ、古いエンドポイント設定と新しいエンドポイント設定が混在してサービスが稼働中であることを意味しています。
[UpdateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html) API を再度呼び出して、エンドポイントを正常な状態に戻すことができます。目的のエンドポイント設定とデプロイ設定 (ローリングデプロイ、ブルー/グリーンデプロイ、またはどちらでもない) を指定して、エンドポイントを更新します。
[DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html) API を呼び出して、エンドポイントの正常性を再確認できます。これは、`Status` フィールドとして `VariantStatus` オブジェクトで返されます。更新が成功すると、エンドポイントの `Status` は `InService` に戻ります。
# Exclusions
Blue/Green デプロイまたはローリングデプロイを実行する場合、新しいエンドポイント設定には古いエンドポイント設定と同じバリアント名が必要です。また、現時点では、エンドポイントがデプロイガードレールの対象外となる機能ベースの除外もあります。エンドポイントで次の機能のいずれかを使用している場合は、エンドポイントでデプロイガードレールを使用することはできません。エンドポイントは、All At Once トラフィックシフトで Blue/Green デプロイを使うようにフォールバックし、最後のベーキング期間はありません。
+ Marketplace コンテナ
+ Inf1 (Inferentiaベース) インスタンスを使うエンドポイント
ローリングデプロイを行う場合は、追加の機能ベースの除外があります。
+ サーバーレス推論エンドポイント
+ マルチバリアント推論エンドポイント
# シャドウテスト
Amazon SageMaker AI を使用すると、現在デプロイされているインフラストラクチャのパフォーマンスと比較することで、モデルを提供するインフラストラクチャへの変更を評価することができます。この方法はシャドウテストと呼ばれています。シャドウテストは、潜在的な設定エラーやパフォーマンスの問題がエンドユーザーに影響を与える前に発見するのに役立ちます。SageMaker AI を使用すると、シャドウテストインフラストラクチャの構築に投資する必要がないため、モデル開発に集中できます。
この機能を使用することで、モデル、コンテナ、インスタンスなど、本番稼働用バリアントのあらゆるコンポーネントへの変更を、エンドユーザーに影響を与えることなく検証できます。これは次のような状況で役立ちます (これらに限定されません)。
+ オフラインで検証された新しいモデルを本番環境に導入することを検討しているものの、この決定を下す前に、レイテンシーやエラー率などの運用パフォーマンス指標を評価したい場合。
+ 脆弱性へのパッチ適用や新しいバージョンへのアップグレードなど、サービス提供インフラストラクチャコンテナへの変更を検討しており、本番環境に移行する前にこれらの変更の影響を評価したい場合。
+ ML インスタンスの変更を検討しており、新しいインスタンスがライブ推論リクエストでどのように機能するかを評価したい場合。
SageMaker AI コンソールには、シャドウテストのワークフローを管理するためのガイド付きのエクスペリエンスが用意されています。事前に設定した期間のシャドウテストを設定し、ライブダッシュボードでテストの進行状況を監視し、完了時にクリーンアップし、結果に基づいてアクションを実行できます。テストしたい本番稼働用バリアントを選択すると、SageMaker AI は自動的に新しいバリアントをシャドウモードでデプロイし、推論リクエストのコピーを同じエンドポイント内でリアルタイムにルーティングします。本番稼働用バリアントの応答のみが呼び出し元のアプリケーションに返されます。シャドウバリアントの応答を破棄するか、オフラインで比較できるようにログに残すかを選択できます。本番稼働用バリアントとシャドウバリアントの詳細については、「[本番環境でのモデルの検証](model-validation.md)」を参照してください。
シャドウテストを作成する手順については、「[シャドウテストを作成する](shadow-tests-create.md)」を参照してください。
**注記**
特定のエンドポイント機能によっては、エンドポイントとシャドウテストに互換性がない場合があります。エンドポイントで次の機能のいずれかを使用している場合、エンドポイントでシャドウテストを使用することはできません。シャドウテストの設定をリクエストすると検証エラーになります。
サーバーレス推論
非同期推論
Marketplace コンテナ
マルチコンテナエンドポイント
マルチモデルエンドポイント
Inf1 (Inferentiaベース) インスタンスを使うエンドポイント
# シャドウテストを作成する
シャドウテストを作成して、シャドウバリアントと本番稼働用バリアントのパフォーマンスを比較できます。推論リクエストを提供している既存のエンドポイントでテストを実行することができ、またテストを実行する新しいエンドポイントを作成することもできます。
シャドウテストを作成するには、次を指定する必要があります。
+ 受信した推論リクエストを 100% 受け取り、応答する本番稼働用バリアント。
+ 受信リクエストを割合で受け取り、本番稼働用バリアントから複製するがレスポンスを返さないシャドウバリアント。
各バリアントについて、SageMaker AI を使用してモデル、インスタンスタイプ、およびインスタンス数を制御できます。シャドウバリアントに複製する受信リクエストの割合 (別名、トラフィックサンプリング率) を設定できます。SageMaker AI はシャドウバリアントへのリクエストの複製を管理し、テストのスケジュール時または実行時にトラフィックのサンプリング率を変更できます。必要に応じて、データキャプチャを有効にして、本番稼働用バリアントおよびシャドウバリアントのリクエストとレスポンスをログに記録することもできます。
**注記**
SageMaker AI は、エンドポイントごとに最大 1 つのシャドウバリアントをサポートします。1 つのシャドウバリアントに 1 つのエンドポイントがある場合、本番稼働用バリアントは最大 1 つです。
いつでもテストを開始し、指定した期間継続するようにスケジュールできます。デフォルトの期間は 7 日で、最大 30 日です。テストが完了すると、エンドポイントはテストを開始する前の状態に戻ります。これにより、テストの完了時にリソースを手動でクリーンアップする必要がなくなります。
SageMaker AI コンソールのダッシュボードから実行しているテストをモニタリングできます。ダッシュボードでは、本番稼働用バリアントとシャドウバリアントの呼び出しメトリクスとインスタンスメトリクスを対照比較でき、関連するメトリクス統計が表形式ビューで表示されます。このダッシュボードは、完了したテストでも使用可能です。メトリクスを確認したら、シャドウバリアントを新しい本番稼働用バリアントに昇格させるか、既存の本番稼働用バリアントを保持するかのいずれかを選択できます。シャドウバリアントを昇格すると、すべての受信リクエストに応答します。詳細については、「[シャドウバリアントを昇格させる](shadow-tests-complete.md#shadow-tests-complete-promote)」を参照してください。
次の手順では、SageMaker AI コンソールからシャドウテストを作成する方法について説明します。既存のエンドポイントを使用するか、シャドウテスト用に新しいエンドポイントを作成するかによって、ワークフローは異なります。
**Topics**
+ [前提条件](#shadow-tests-create-prerequisites)
+ [シャドウテストの詳細を入力する](#shadow-tests-create-console-shadow-test-details)
+ [シャドウテストの設定を入力する](#shadow-tests-create-console-shadow-test-settings)
## 前提条件
SageMaker AI コンソールでシャドウテストを作成する前に、SageMaker AI モデルを使用する準備をしておく必要があります。SageMaker AI モデルの作成方法については、「[リアルタイム推論用のモデルをデプロイする](realtime-endpoints-deploy-models.md)」を参照してください。
既存のエンドポイントと本番稼働用バリアントおよびシャドウバリアント、既存のエンドポイントと本番稼働用バリアントのみ、または比較する SageMaker AI モデルだけを使用してシャドウテストを開始できます。シャドウテストは、テスト開始前のエンドポイントの作成とバリアントの追加をサポートしています。
**注記**
特定のエンドポイント機能によっては、エンドポイントとシャドウテストに互換性がない場合があります。エンドポイントで次の機能のいずれかを使用している場合、エンドポイントでシャドウテストを使用することはできません。シャドウテストの設定をリクエストすると検証エラーになります。
サーバーレス推論
非同期推論
Marketplace コンテナ
マルチコンテナエンドポイント
マルチモデルエンドポイント
Inf1 (Inferentiaベース) インスタンスを使うエンドポイント
## シャドウテストの詳細を入力する
シャドウテストの作成を開始するには、次の作業を行って **[シャドウテストの詳細を入力]** ページに入力します。
1. [SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/)を開きます。
1. 左側のナビゲーションパネルで **[推論]** を選択し、次に **[シャドウテスト]** を選択します。
1. **[シャドウテストを作成]** を選択します。
1. **[名前]** に、テストの名前を入力します。
1. (オプション) **[説明]** に、テストの説明を入力します。
1. (オプション) **キー**と**値**のペアを使用して**タグ**を指定します。
1. [**次へ**] を選択します。
## シャドウテストの設定を入力する
**[シャドウテストの詳細を入力]** ページに入力した後、**[シャドウテスト設定を入力]** ページに入力します。既に SageMaker AI 推論エンドポイントと本番稼働用バリアントがある場合は、**[既存のエンドポイントを使用]** ワークフローに従ってください。エンドポイントをまだ作成していない場合は、**[新しいエンドポイントを作成]** ワークフローに従ってください。
------
#### [ Use an existing endpoint ]
テストに既存のエンドポイントを使用する場合は、次の作業を行って **[シャドウテスト設定を入力]** ページに入力します。
1. `AmazonSageMakerFullAccess` IAM ポリシーがアタッチされたロールを選択します。
1. **[既存のエンドポイントを使用]** を選択し、使用可能なエンドポイントの 1 つを選択します。
1. (オプション) エンドポイントのストレージボリュームを暗号化するには、既存の KMS キーを選択するか、**[暗号化キー]** の下のドロップダウンリストから **[KMS キー ARN を入力]** を選択します。2 番目のオプションを選択すると、KMS キー ARN を入力するフィールドが表示されます。そのフィールドに KMS キー ARN を入力します。
1. そのエンドポイントの背後に複数の本番稼働用バリアントがある場合、テストに使用しないバリアントを削除してください。モデルバリアントを削除するには、そのモデルバリアントを選択して **[削除]** を選択します。
1. シャドウバリアントがまだない場合は、シャドウバリアントを追加してください。シャドウバリアントを追加するには、次の作業を行います。
1. **[Add]** (追加) を選択します。
1. **[シャドウバリアント]** を選択します。
1. **[モデルの追加]** ダイアログボックスで、シャドウバリアントに使用するモデルを選択します。
1. **[保存]** を選択します。
1. (オプション) 前述のステップでは、シャドウバリアントはデフォルトの設定で追加されます。これらの設定を変更するには、シャドウバリアントを選択して **[編集]** を選択します。**[シャドウバリアントを編集]** ダイアログボックスが表示されます。このダイアログボックスの入力方法の詳細については、「[シャドウテストを編集する](shadow-tests-view-monitor-edit-individual.md)」を参照してください。
1. **[スケジュール]** セクションで、次のようにテスト期間を入力します。
1. **[期間]** の下のボックスを選択します。ポップアップカレンダーが表示されます。
1. カレンダーから開始日と終了日を選択するか、**[開始日]** と **[終了日]** のフィールドにそれぞれ開始日と終了日を入力します。
1. (オプション) **[開始時刻]** と **[終了時刻]** のフィールドには、それぞれ開始時刻と終了時刻を 24 時間形式で入力します。
1. **[Apply]** (適用) を選択します。
最短期間は 1 時間、最長期間は 30 日です。
1. (オプション) **[データキャプチャを有効にする**] をオンにして、エンドポイントからの推論リクエストとレスポンス情報を Amazon S3 バケットに保存し、Amazon S3 バケットの場所を入力します。
1. **[シャドウテストを作成]** を選択します。
------
#### [ Create a new endpoint ]
既存のエンドポイントがない場合、またはテスト用に新しいエンドポイントを作成する場合は、**[シャドウテスト設定を入力]** ページに次のように入力します。
1. `AmazonSageMakerFullAccess` IAM ポリシーがアタッチされたロールを選択します。
1. **[新しいエンドポイントを作成]** を選択します。
1. **[名前]** に、エンドポイントの名前を入力します。
1. 1 つの本番稼働用バリアントと 1 つのシャドウバリアントをエンドポイントに追加します。
+ 本番稼働用バリアントを追加するには、**[追加]** を選択し、**[本番稼働用バリアント]** を選択します。**[モデルの追加]** ダイアログボックスで、本番稼働用バリアントに使用するモデルを選択し、**[保存]** を選択します。
+ シャドウバリアントを追加するには、**[追加]** を選択し、**[シャドウバリアント]** を選択します。**[モデルの追加]** ダイアログボックスで、シャドウバリアントに使用するモデルを選択し、**[保存]** を選択します。
1. (オプション) 前述のステップでは、シャドウバリアントはデフォルトの設定で追加されます。これらの設定を変更するには、シャドウバリアントを選択して **[編集]** を選択します。**[シャドウバリアントを編集]** ダイアログボックスが表示されます。このダイアログボックスの入力方法の詳細については、「[シャドウテストを編集する](shadow-tests-view-monitor-edit-individual.md)」を参照してください。
1. **[スケジュール]** セクションで、次のようにテスト期間を入力します。
1. **[期間]** の下のボックスを選択します。ポップアップカレンダーが表示されます。
1. カレンダーから開始日と終了日を選択するか、**[開始日]** と **[終了日]** にそれぞれ開始日と終了日を入力します。
1. (オプション) **[開始時刻]** と **[終了時刻]** に、それぞれ開始時刻と終了時刻を 24 時間形式で入力します。
1. **[Apply]** (適用) を選択します。
最短期間は 1 時間、最長期間は 30 日です。
1. (オプション) **[データキャプチャを有効にする**] をオンにして、エンドポイントからの推論リクエストとレスポンス情報を Amazon S3 バケットに保存し、Amazon S3 バケットの場所を入力します。
1. **[シャドウテストを作成]** を選択します。
------
上述の手順を完了すると、指定した開始日時にテストが開始するようにスケジュールされます。テストの進行状況はダッシュボードから確認できます。テストの表示と実行可能なアクションの詳細については、「[シャドウテストを表示、監視、編集する方法](shadow-tests-view-monitor-edit.md)」を参照してください。
# シャドウテストを表示、監視、編集する方法
シャドウテストのステータスの確認、ダッシュボードからの進行状況の監視をしたり、テストの早期開始や停止、テストの削除などのアクションを実行したりできます。以下のトピックでは、SageMaker AI コンソールを使用してシャドウテストを表示および変更する方法について説明します。
**Topics**
+ [シャドウテストを表示する](shadow-tests-view-monitor-edit-list.md)
+ [シャドウテストを監視する](shadow-tests-view-monitor-edit-dashboard.md)
+ [シャドウテストを早期開始する](shadow-tests-view-monitor-edit-start.md)
+ [シャドウテストを削除する](shadow-tests-view-monitor-edit-delete.md)
+ [シャドウテストを編集する](shadow-tests-view-monitor-edit-individual.md)
# シャドウテストを表示する
SageMaker AI コンソールの **[シャドウテスト]** ページで、すべてのシャドウテストのステータスを表示できます。
コンソールでテストを表示するには、次の作業を行います:
1. [SageMaker AI コンソール](https://console.aws.amazon.com/sagemaker/)を開きます。
1. [ナビゲーション] パネルで、**[推論]** を選択します。
1. **[シャドウテスト]** を選択すると、すべてのシャドウテストを一覧表示するページが表示されます。次のスクリーンショットのようなページが表示され、**[シャドウテスト]** セクションにすべてのテストが一覧表示されます。
![\[すべてのシャドウテストのリスト。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/juxtaposer/shadow-test-landing-page.png)
**[シャドウテスト]** ページのコンソールで、テストの **[ステータス]** フィールドを確認することにより、テストのステータスを確認できます。
テストの有効なステータスは、次のとおりです。
+ `Creating` — SageMaker AI がテストを作成しています。
+ `Created` — SageMaker AI がテストの作成を完了し、スケジュールされた時間にテストが開始されます。
+ `Updating` — テストを変更しているとき、更新中と表示されます。
+ `Starting` — SageMaker AI がテストを開始しています。
+ `Running` — テストが進行中です。
+ `Stopping` — SageMaker AI がテストを停止しています。
+ `Completed` — テストが完了しました。
+ `Cancelled` — テストを早期終了すると、キャンセル済みと表示されます。
# シャドウテストを監視する
シャドウテストの進行中または完了後に、シャドウテストの詳細を表示し、監視できます。SageMaker AI は、本番稼働用バリアントとシャドウバリアントのモデルのレイテンシーや集計されたエラー率などの運用メトリクスを比較するライブダッシュボードを表示します。
コンソールで個別のテストの詳細を表示するには、次の作業を行います。
1. **[シャドウテスト]** ページの **[シャドウテスト]** セクションから、監視するテストを選択します。
1. **[アクション]** ドロップダウンリストから、**[表示]** を選択します。テストの詳細が含まれる概要ページとメトリクスダッシュボードが表示されます。
概要ページには次の 3 つのセクションがあります。
**概要**
このセクションには、テストの進行状況とステータスの概要が表示されます。また、**[メトリクス]** サブセクションの **[メトリクスの選択]** ドロップダウンリストから選択したメトリクスのサマリー統計も表示されます。次のスクリーンショットは、このセクションを示しています。
![\[概要ページのサマリー統計。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/juxtaposer/shadow-test-summary.png)
前述のスクリーンショットにおいて、**[設定]** タブと **[詳細]** タブに、選択した設定とテストの作成時に入力した詳細が表示されています。
**分析**
このセクションには、次のメトリクスを個別のグラフで示すメトリクスダッシュボードが表示されます:
+ `Invocations`
+ `InvocationsPerInstance`
+ `ModelLatency`
+ `Invocation4XXErrors`
+ `Invocation5XXErrors`
+ `InvocationModelErrors`
+ `CPUUtilization`
+ `MemoryUtilization`
+ `DiskUtilization`
最後の 3 つのメトリクスは、モデルコンテナのランタイムリソースの使用状況を監視します。残りは、バリアントのパフォーマンスを分析するために使用できる CloudWatch メトリクスです。一般的に、エラーが少ないほどモデルが安定していることを示します。レイテンシーが低いほど、モデルが高速であるか、インフラストラクチャが高速であることを示しています。CloudWatch のメトリクスの詳細については、「[SageMaker AI エンドポイント呼び出しメトリクス](monitoring-cloudwatch.md#cloudwatch-metrics-endpoint-invocation)」を参照してください。次のスクリーンショットは、メトリクスダッシュボードを示しています。
![\[メトリクス分析のダッシュボード。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/juxtaposer/shadow-test-analysis.png)
**環境**
このセクションには、テストで比較したバリアントが表示されます。シャドウバリアントのパフォーマンスに満足した場合、前述のメトリクスに基づき、**[シャドウバリアントをデプロイ]** を選択してシャドウバリアントを本番稼働用バリアントに昇格できます。シャドウバリアントのデプロイの詳細については、「[シャドウバリアントを昇格させる](shadow-tests-complete.md#shadow-tests-complete-promote)」を参照してください。また、**[トラフィックを編集]** を選択してトラフィックのサンプリング率を変更し、テストを続行することもできます。シャドウバリアントの編集の詳細については、「[シャドウテストを編集する](shadow-tests-view-monitor-edit-individual.md)」を参照してください。次のスクリーンショットは、このセクションを示しています。
![\[概要ページの環境セクション。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/juxtaposer/shadow-test-environment.png)
# シャドウテストを早期開始する
スケジュールした開始時刻より前にテストを開始することができます。新しいテスト期間が 30 日を超える場合、SageMaker AI は自動的にテストの終了を新しい開始時刻から 30 日後に設定します。このアクションはテストをすぐに開始します。テストの開始時刻または終了時刻を変更する場合は、「[シャドウテストを編集する](shadow-tests-view-monitor-edit-individual.md)」を参照してください。
スケジュールされた開始時刻より前に、テストをコンソールからすぐに開始するには、次を行います。
1. **[シャドウテスト]** ページの **[シャドウテスト]** セクションから、すぐに開始するテストを選択します。
1. **[アクション]** ドロップダウンリストから、**[開始]** を選択します。**[シャドウテストを開始しますか]** ダイアログボックスが表示されます。
1. **[今すぐ開始]** を選択します。
# シャドウテストを削除する
不要になったテストは削除することができます。テストの削除はメタデータのみを削除し、エンドポイント、バリアント、または Amazon S3 でキャプチャされたデータは削除されません。エンドポイントの実行を停止するには、エンドポイントを削除する必要があります。エンドポイントの削除の詳細については、「[エンドポイントとリソースを削除する](realtime-endpoints-delete-resources.md)」を参照してください。
コンソールからテストを削除するには、次の作業を行います。
1. **[シャドウテスト]** ページの **[シャドウテスト]** セクションから削除するテストを選択します。
1. **[アクション]** ドロップダウンリストから、**[削除]** を選択します。**[シャドウテストを削除する]** ダイアログボックスが表示されます。
1. **[フィールドに*削除*と入力して、削除を確認します。]** テキストボックスで、**delete** と入力してください。
1. **[削除]** を選択します。
# シャドウテストを編集する
スケジュールされたテストと進行中のテストの両方を変更できます。テストを開始する前に、テストの説明、シャドウバリアントの設定、開始日、終了日を変更できます。データキャプチャをオンまたはオフにすることもできます。
テストが開始した後に変更できるのは、説明、シャドウバリアントのトラフィックサンプリング率、および終了日だけです。
コンソールからテストの詳細を編集するには、次の作業を行います。
1. **[シャドウテスト]** ページの **[シャドウテスト]** セクションから編集するテストを選択します。
1. **[アクション]** ドロップダウンリストから、**[編集]** を選択します。**[シャドウテストの詳細を入力]** ページが表示されます。
1. (オプション) **[説明]** にテストの説明を入力します。
1. [**次へ**] を選択します。**[シャドウテスト設定を入力]** ページが表示されます。
1. (オプション) シャドウバリアントを編集するには、次の作業を行います。
1. シャドウバリアントを選択し、**[編集]** を選択します。**[シャドウバリアントを編集]** ダイアログボックスが表示されます。テストが既に開始されている場合、変更できるのはトラフィックのサンプリング率だけです。
1. (オプション) **[名前]** に、古い名前と置き換える新しい名前を入力します。
1. (オプション) **[トラフィックサンプル]** に、古いトラフィックサンプリング率と置き換える新しいトラフィックサンプリング率を入力します。
1. (オプション) **[インスタンスタイプ]** で、ドロップダウンリストから新しいインスタンスタイプを選択します。
1. (オプション) **[インスタンス数]** に、古いインスタンス数と置き換える新しいインスタンス数を入力します。
1. **[Apply]** (適用) を選択します。
上記の手順で、シャドウバリアントのモデルを変更することはできません。モデルを変更する場合は、まずシャドウバリアントを選択して **[削除]** を選択し、削除します。次に、新しいシャドウバリアントを追加します。
1. (オプション) テスト期間を編集するには、次の作業を行います。
1. **[スケジュール]** セクションの **[期間]** の下にあるボックスを選択します。ポップアップカレンダーが表示されます。
1. テストがまだ開始されていない場合は、開始日と終了日の両方を変更できます。カレンダーから新しい開始日と終了日を選択するか、**[開始日]** と **[終了日]** にそれぞれ新しい開始日と終了日を入力します。
テストが既に開始されている場合、変更できるのは終了日のみです。**[終了日]** に新しい終了日を入力します。
1. (オプション) テストがまだ開始されていない場合は、開始時刻と終了時刻の両方を変更できます。**[開始時刻]** と **[終了時刻]** に新しい開始時刻と終了時刻をそれぞれ 24 時間形式で入力します。
テストが既に開始されている場合、変更できるのは終了時刻だけです。**[終了時刻]** に新しい終了時刻を 24 時間形式で入力します。
1. **[Apply]** (適用) を選択します。
1. (オプション) **[データキャプチャを有効にする]** をオンまたはオフにします。
1. **[シャドウテストを更新]** を選択します。
# シャドウテストを完了する
テストはスケジュール期間の終了時に自動的に完了しますが、進行中のテストを早期に中止することもできます。テストが完了すると、**[シャドウテスト]** ページにある **[シャドウテスト]** セクションのテスト状態は **[完了]** と表示されます。その後、テストの最終メトリクスを確認して分析します。
メトリクスダッシュボードを使用して、シャドウバリアントを本番稼働用に昇格させるかどうかを決定します。テストのメトリクスダッシュボード分析の詳細については、「[シャドウテストを監視する](shadow-tests-view-monitor-edit-dashboard.md)」を参照してください。
予定完了時間の前にテストを完了する方法については、「[シャドウテストを早めに完了する](#shadow-tests-complete-early)」を参照してください。
シャドウバリアントを本番稼働用に昇格させる手順については、「[シャドウバリアントを昇格させる](#shadow-tests-complete-promote)」を参照してください。
## シャドウテストを早めに完了する
進行中のシャドウテストを完了する必要がある理由の 1 つは、シャドウバリアントのメトリクスが良好であると判断し、それを本番稼働用に昇格させたい場合です。また、1 つ以上のバリアントのパフォーマンスが良好ではない場合、テストを完了することもできます。
予定終了日より前にテストを完了するには、次の作業を行います。
1. **[シャドウテスト]** ページの **[シャドウテスト]** セクションから、完了としてマークするテストを選択します。
1. **[アクション]** ドロップダウンリストから **[完了]** を選択すると、**[シャドウテストの完了]** ダイアログボックスが表示されます。
1. ダイアログボックスで、次のいずれかを選択します。
+ **はい、シャドウバリアントをデプロイします。**
+ **いいえ、シャドウバリアントを削除します。**
1. (オプション) **[コメント]** テキストボックスに、予定終了時間より前にテストを完了する理由を入力します。
1.
1. シャドウバリアントをデプロイする場合は、**[完了してデプロイに進む]** を選択します。**[シャドウバリアントをデプロイ]** のページが表示されます。このページの入力方法については、「[シャドウバリアントを昇格させる](#shadow-tests-complete-promote)」を参照してください。
1. シャドウバリアントを削除する場合は、**[確認]** を選択します。
## シャドウバリアントを昇格させる
本番稼働用バリアントをシャドウバリアントに置き換える場合、エンドポイントを更新し、推論リクエストに応答するようにシャドウバリアントを昇格させることができます。これにより、現在の本番稼働用バリアントが本番環境から削除され、シャドウバリアントに置き換えられます。
シャドウテストがまだ進行中の場合は、まずテストを完了させる必要があります。予定終了時間の前にシャドウテストを完了するには、このセクションを続行する前に「[シャドウテストを早めに完了する](#shadow-tests-complete-early)」の手順に従ってください。
シャドウバリアントを本番稼働用に昇格させる場合、シャドウバリアントのインスタンス数には次のオプションがあります。
+ 本番稼働用バリアントのインスタンス数とタイプを保持できます。このオプションを選択すると、シャドウバリアントは現在のインスタンス数で本番環境で起動するため、モデルは同じスケールでリクエストトラフィックを引き続き処理できます。
+ シャドウバリアントのインスタンス数とタイプを保持できます。このオプションを使用する場合、シャドウバリアントが現在のスケールでリクエストトラフィックを処理できることを確認するために、100% のトラフィックサンプリングでシャドウテストを行うことをお勧めします。
+ インスタンスの数とタイプにカスタム値を使用できます。このオプションを使用する場合、シャドウバリアントが現在のスケールでリクエストトラフィックを処理できることを確認するために、100% のトラフィックサンプリングでシャドウテストを行うことをお勧めします。
シャドウバリアントのインスタンスタイプまたは数、あるいはその両方を検証する場合を除き、シャドウバリアントを昇格させる際には、本番稼働用バリアントのインスタンス数とタイプを保持することを強くお勧めします。
シャドウバリアントを昇格させるには、次の作業を行います。
1. テストが完了したら、次の作業を行います。
1. **[シャドウテスト]** ページの **[シャドウテスト]** セクションからテストを選択します。
1. **[アクション]** ドロップダウンリストから、**[表示]** を選択します。ダッシュボードが表示されます。
1. **[環境]** セクションから **[シャドウバリアントをデプロイ]** を選択します。**[シャドウバリアントをデプロイ]** のページが表示されます。
テストが完了していない場合は、「[シャドウテストを早めに完了する](#shadow-tests-complete-early)」を参照して完了してください。
1. **[バリアント設定]** セクションで、次のいずれかのオプションを選択します。
+ **[本番稼働用設定を保持]**
+ **[シャドウ設定を保持]**
+ **[カスタムインスタンスの設定]**
**[カスタムインスタンスの設定]** を選択した場合は、次の操作を行います。
1. **[インスタンスタイプ]** ドロップダウンリストからインスタンスタイプを選択します。
1. **[インスタンス数]** に、インスタンス数を入力します。
1. **[デプロイを確定するには「deploy」と入力してください]** とあるテキストボックスに、「**deploy**」と入力します。
1. **[シャドウバリアントをデプロイ]** を選択します。
SageMaker AI Inference エンドポイントは、シャドウバリアントを本番稼働用バリアントとして使用するようになり、本番稼働用バリアントはエンドポイントから削除されます。
# ベストプラクティス
推論実験を作成するときは、次の情報に注意してください。
+ **トラフィックサンプリング率** — 推論リクエストを 100% サンプリングすることで、シャドウバリアントが昇格時に本番稼働トラフィックを処理できることを検証できます。最初は低いトラフィックサンプリング率から始め、バリアントの信頼性を高めることができたら徐々に増やすこともできますが、昇格前にトラフィックを 100% まで確実に増やすことがベストプラクティスです。
+ **インスタンスタイプ** — シャドウバリアントを使用して代替インスタンスタイプまたはサイズを評価する場合を除き、同じインスタンスタイプ、サイズ、数を使用することをお勧めします。これにより、昇格した後にシャドウバリアントが大量の推論リクエストを確実に処理できるようになります。
+ **自動スケーリング** — シャドウバリアントが推論リクエスト数の急増や推論リクエストパターンの変化に確実に対応できるようにするには、シャドウバリアントに自動スケーリングを設定することを強くお勧めします。自動スケーリングの設定方法の詳細については、「[Amazon SageMaker AI モデルの自動スケーリング](endpoint-auto-scaling.md)」を参照してください。自動スケーリングを設定している場合は、ユーザーに影響を与えることなく、自動スケーリングポリシーの変更を検証することもできます。
+ **メトリクスのモニタリング** — シャドウ実験を開始して十分な呼び出しが行われた後、メトリクスダッシュボードをモニタリングして、レイテンシーやエラー率などのメトリクスが許容範囲内であることを確認します。これにより、設定ミスを早期に発見し、是正措置を講じることができます。進行中の推論実験のメトリクスをモニタリングする方法の詳細については、「[シャドウテストを表示、監視、編集する方法](shadow-tests-view-monitor-edit.md)」を参照してください。
# SSM 経由でコンテナにアクセスする
Amazon SageMaker AI を使用すると、 AWS Systems Manager (SSM) を使用して、モデルが推論用にデプロイされている Docker コンテナに安全に接続できます。これにより、コンテナへのシェルレベルのアクセスが可能になり、コンテナ内で実行されているプロセスをデバッグし、Amazon CloudWatch でコマンドと応答を記録できます。コンテナをホストする ML インスタンス AWS PrivateLink への接続を設定して、SSM 経由でコンテナにプライベートにアクセスすることもできます。
**警告**
SSM アクセスを有効にすると、エンドポイントのパフォーマンスに影響することがあります。この機能は、本番環境のエンドポイントではなく、開発用またはテスト用のエンドポイントで使用することをお勧めします。また、SageMaker AI はセキュリティパッチを自動的に適用し、問題のあるエンドポイントインスタンスを 10 分以内に置換または終了します。ただし、SSM が有効になっている本番稼働用バリアントを使用するエンドポイントの場合、SageMaker AI はデバッグを可能にするために、セキュリティパッチの適用と障害のあるエンドポイントインスタンスの置換または終了を 1 日遅らせます。
次のセクションでは、この機能の使用方法について詳しく説明します。
## 許可リスト
この機能を使用するには、カスタマーサポートに連絡し、アカウントを許可リストに登録する必要があります。アカウントが SSM アクセスの許可リストに登録されていない場合、SSM アクセスが有効なエンドポイントを作成することはできません。
## SSM アクセスを有効にする
エンドポイントの既存コンテナへの SSM アクセスを有効にするには、`EnableSSMAccess` パラメータを `true` に設定した新しいエンドポイント設定でエンドポイントを更新します。次の例は、エンドポイント設定のサンプルを示しています。
```
{
"EndpointConfigName": "endpoint-config-name",
"ProductionVariants": [
{
"InitialInstanceCount": 1,
"InitialVariantWeight": 1.0,
"InstanceType": "ml.t2.medium",
"ModelName": model-name,
"VariantName": variant-name,
"EnableSSMAccess": true,
},
]
}
```
SSM アクセスを有効にする方法の詳細については、「[EnableSSMAccess](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProductionVariant.html#API_EnableSSMAccess)」を参照してください。
## IAM の設定
### エンドポイントの IAM アクセス権限
エンドポイントインスタンスの SSM アクセスを有効にした場合、SageMaker AI はエンドポイントインスタンスを開始する際、[SSM エージェント](https://docs.aws.amazon.com/systems-manager/latest/userguide/ssm-agent.html)を起動して管理します。SSM エージェントが SSM サービスと通信できるようにするには、エンドポイントが実行される実行ロールに次のポリシーを追加します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssmmessages:CreateControlChannel",
"ssmmessages:CreateDataChannel",
"ssmmessages:OpenControlChannel",
"ssmmessages:OpenDataChannel"
],
"Resource": "*"
}
]
}
```
------
### ユーザーの IAM アクセス許可
次のポリシーを追加して、IAM ユーザーに SSM ターゲットに接続するための SSM セッションアクセス許可を付与します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:StartSession",
"ssm:TerminateSession"
],
"Resource": "*"
}
]
}
```
------
次のポリシーを使用して、IAM ユーザーが接続できるエンドポイントを制限できます。*イタリック体のプレースホルダーテキスト*を独自の情報に置き換えます。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:StartSession"
],
"Resource": "arn:aws:sagemaker:us-east-2:111122223333:endpoint/endpoint-name"
}
]
}
```
------
## を使用した SSM アクセス AWS PrivateLink
エンドポイントがパブリックインターネットに接続されていない Virtual Private Cloud (VPC) 内で実行されている場合、 AWS PrivateLink を使用して SSM を有効にできます。 AWS PrivateLink は、エンドポイントインスタンス、SSM、Amazon EC2 間のすべてのネットワークトラフィックを Amazon ネットワークに制限します。 AWS PrivateLinkで SSM アクセスを設定する方法の詳細については、「[Session Manager の VPC エンドポイントを設定する](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-getting-started-privatelink.html)」を参照してください。
## Amazon CloudWatch Logs でのロギング
SSM アクセスが有効なエンドポイントでは、Amazon CloudWatch Logs を使用して SSM エージェントからのエラーをログに記録できます。CloudWatch Logs でエラーをログに記録する方法の詳細については、「[Logging session activity](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-logging.html)」を参照してください。ログは、エンドポイントロググループ `/aws/sagemaker/endpoints/endpoint-name` 下の SSM ログストリーム `variant-name/ec2-instance-id/ssm` にあります。ログの表示方法の詳細については、「[CloudWatch Logs に送信されたログデータを表示する](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData)」を参照してください。
エンドポイントの背後にある本番稼働用バリアントには、複数のモデルコンテナを含めることができます。各モデルコンテナのログはログストリームに記録されます。各ログの先頭には `[sagemaker ssm logs][container-name]` が付きます。ここで、`container-name` はコンテナに付けた名前か、`container_0`、`container_1` などのデフォルトの名前です。
## モデルコンテナへのアクセス
エンドポイントインスタンスのモデルコンテナにアクセスするには、ターゲット ID が必要です。ターゲット ID は次のいずれかの形式です。
+ `sagemaker-endpoint:endpoint-name_variant-name_ec2-instance-id` 単一コンテナエンドポイントのコンテナ用
+ `sagemaker-endpoint:endpoint-name_variant-name_ec2-instance-id_container-name` マルチコンテナエンドポイントのコンテナ用
次の例は、 を使用してターゲット ID を使用してモデルコンテナ AWS CLI にアクセスする方法を示しています。
```
aws ssm start-session --target sagemaker-endpoint:prod-image-classifier_variant1_i-003a121c1b21a90a9_container_1
```
[Amazon CloudWatch Logs でのロギング](#ssm-access-logging) で述べているようにログ記録を有効にすると、SSM ログストリームの最初にリストされているすべてのコンテナのターゲット ID を確認できます。
**注記**
SSM を使用して、1P アルゴリズムコンテナや SageMaker AI MarketPlace から取得したモデルのコンテナに接続することはできません。ただし、 AWS が提供する深層学習コンテナ (DLC) や、所有する任意のカスタムコンテナには接続できます。
モデルコンテナのネットワーク分離を有効にして、アウトバウンドのネットワーク呼び出しを行えないようにしている場合、そのコンテナの SSM セッションを開始することはできません。
1 つの SSM セッションから 1 つのコンテナにのみアクセスできます。同じエンドポイントの背後にあるコンテナであっても、別のコンテナにアクセスするには、そのエンドポイントのターゲット ID を使用して新しい SSM セッションを開始します。
# Amazon SageMaker AI でのモデルデプロイ用のモデルサーバー
TorchServe、DJL Serving、Triton Inference Server などの一般的なモデルサーバーを使用して、SageMaker AI でモデルをデプロイできます。次のトピックでは、その方法を説明します。
**Topics**
+ [TorchServe を使用したモデルのデプロイ](deploy-models-frameworks-torchserve.md)
+ [DJL サービングを使用したモデルのデプロイ](deploy-models-frameworks-djl-serving.md)
+ [Triton Inference Server によるモデルのデプロイ](deploy-models-frameworks-triton.md)
# TorchServe を使用したモデルのデプロイ
TorchServe は、 AWS PyTorch 深層学習コンテナ (DLC) にプリインストールされた PyTorch 用の推奨モデルサーバーです。この強力なツールは、モデルのサイズやディストリビューションに関係なく、CPU、GPU、Neuron、Graviton などのさまざまな AWS インスタンスに複数の PyTorch モデルをデプロイする際に高いパフォーマンスを提供し、一貫性のあるユーザーフレンドリーなエクスペリエンスをお客様に提供します。
TorchServe は、動的バッチ処理、マイクロバッチ処理、モデル A/B テスト、ストリーミング、トーチ XLA、TensorRT、ONNX、IPEX など、さまざまな高度な機能をサポートしています。さらに、PyTorch の大規模モデルソリューションである PiPPy をシームレスに統合できるため、大規模モデルを効率的に処理できます。また、TorchServe は、DeepSpeed、Accelerate、Fast Transformers などの一般的なオープンソースライブラリにもサポートを拡張し、その機能をさらに拡張しています。TorchServe を使用すると、 AWS ユーザーは PyTorch モデルを確実にデプロイして提供できるため、さまざまなハードウェア設定やモデルタイプで汎用性と最適化されたパフォーマンスを活用できます。詳細な情報については、「[PyTorch のドキュメント](https://pytorch.org/serve/)」と「[GitHub の TorchServe](https://github.com/pytorch/serve)」を参照してください。
次の表に、 AWS TorchServe でサポートされている PyTorch TorchServe DLCs を示します。
| インスタンスタイプ | SageMaker AI PyTorch DLC リンク |
| --- | --- |
| CPU および GPU | [SageMaker AI PyTorch コンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) |
| Neuron | [PyTorch Neuron コンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#neuron-containers) |
| Graviton | [SageMaker AI PyTorch Graviton コンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-graviton-containers-sm-support-only) |
以下のセクションでは、Amazon SageMaker AI で PyTorch DLC をビルドしてテストするためのセットアップについて説明します。
## 開始方法
開始するには、次の前提条件が整っていることを確認してください。
1. AWS アカウントにアクセスできることを確認します。が IAM ユーザーまたは IAM AWS ロールを介してアカウント AWS CLI にアクセスできるように環境を設定します。IAM ロールの使用をお勧めします。個人アカウントでテストする目的で、以下の管理アクセス許可ポリシーを IAM ロールにアタッチできます。
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AWS ServiceRoleForAmazonEKSNodegroup](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AWSServiceRoleForAmazonEKSNodegroup)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
1. 次の例のように、依存関係をローカルに設定します。
```
from datetime import datetime
import os
import json
import logging
import time
# External Dependencies:
import boto3
from botocore.exceptions import ClientError
import sagemaker
sess = boto3.Session()
sm = sess.client("sagemaker")
region = sess.region_name
account = boto3.client("sts").get_caller_identity().get("Account")
smsess = sagemaker.Session(boto_session=sess)
role = sagemaker.get_execution_role()
# Configuration:
bucket_name = smsess.default_bucket()
prefix = "torchserve"
output_path = f"s3://{bucket_name}/{prefix}/models"
print(f"account={account}, region={region}, role={role}")
```
1. 次の例に示すように、PyTorch の DLC イメージを取得します。
SageMaker AI PyTorch DLC イメージは、すべての AWS リージョンで利用できます。詳細については、「[DLC コンテナイメージのリスト](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only)」を参照してください。
```
baseimage = sagemaker.image_uris.retrieve(
framework="pytorch",
region="",
py_version="py310",
image_scope="inference",
version="2.0.1",
instance_type="ml.g4dn.16xlarge",
)
```
1. ローカルワークスペースの作成
```
mkdir -p workspace/
```
## パッケージの追加
以下のセクションでは、PyTorch DLC イメージにパッケージを追加および事前インストールする方法について説明します。
**BYOC のユースケース**
以下の手順は、PyTorch DLC イメージにパッケージを追加する方法を示しています。コンテナのカスタマイズの詳細については、[AWS 「深層学習コンテナのカスタムイメージの構築](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md)」を参照してください。
1. PyTorch DLC Docker イメージにパッケージを追加するとします。次の例に示すように、`docker` ディレクトリの下に Dockerfile を作成します。
```
mkdir -p workspace/docker
cat workspace/docker/Dockerfile
ARG BASE_IMAGE
FROM $BASE_IMAGE
#Install any additional libraries
RUN pip install transformers==4.28.1
```
1. 次の [build\$1and\$1push.sh](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/docker/build_and_push.sh) スクリプトを使用して、カスタマイズした Docker イメージをビルドして公開します。
```
# Download script build_and_push.sh to workspace/docker
ls workspace/docker
build_and_push.sh Dockerfile
# Build and publish your docker image
reponame = "torchserve"
versiontag = "demo-0.1"
./build_and_push.sh {reponame} {versiontag} {baseimage} {region} {account}
```
**SageMaker AI プリインストールのユースケース**
次の例は、PyTorch DLC コンテナにパッケージをプリインストールする方法を示しています。`requirements.txt` ファイルはディレクトリ `workspace/code` の下にローカルに作成する必要があります。
```
mkdir -p workspace/code
cat workspace/code/requirements.txt
transformers==4.28.1
```
## TorchServe モデルアーティファクトの作成
次の例では、事前トレーニング済みの [MNIST モデル](https://github.com/pytorch/serve/tree/master/examples/image_classifier/mnist)を使用します。ディレクトリ `workspace/mnist` を作成し、[TorchServe カスタムサービスの手順](https://github.com/pytorch/serve/blob/master/docs/custom_service.md#custom-service)に従って [mnist\$1handler.py](https://github.com/pytorch/serve/blob/master/examples/image_classifier/mnist/mnist_handler.py) を実装し、[model-config.yaml](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/workspace/lama/model-config.yaml) で[モデルパラメータを設定](https://github.com/pytorch/serve/tree/master/model-archiver#config-file) (バッチサイズやワーカーなど) します。次に、TorchServe ツール `torch-model-archiver` を使用してモデルアーティファクトを構築し、Amazon S3 にアップロードします。
1. `model-config.yaml` でモデルパラメータを設定します。
```
ls -al workspace/mnist-dev
mnist.py
mnist_handler.py
mnist_cnn.pt
model-config.yaml
# config the model
cat workspace/mnist-dev/model-config.yaml
minWorkers: 1
maxWorkers: 1
batchSize: 4
maxBatchDelay: 200
responseTimeout: 300
```
1. [torch-model-archiver](https://github.com/pytorch/serve/tree/master/model-archiver#torch-model-archiver-for-torchserve) を使用してモデルアーティファクトを構築します。
```
torch-model-archiver --model-name mnist --version 1.0 --model-file workspace/mnist-dev/mnist.py --serialized-file workspace/mnist-dev/mnist_cnn.pt --handler workspace/mnist-dev/mnist_handler.py --config-file workspace/mnist-dev/model-config.yaml --archive-format tgz
```
パッケージをプリインストールする場合は、`code` ディレクトリを `tar.gz` ファイルに含める必要があります。
```
cd workspace
torch-model-archiver --model-name mnist --version 1.0 --model-file mnist-dev/mnist.py --serialized-file mnist-dev/mnist_cnn.pt --handler mnist-dev/mnist_handler.py --config-file mnist-dev/model-config.yaml --archive-format no-archive
cd mnist
mv ../code .
tar cvzf mnist.tar.gz .
```
1. `mnist.tar.gz` を Amazon S3 にアップロードします。
```
# upload mnist.tar.gz to S3
output_path = f"s3://{bucket_name}/{prefix}/models"
aws s3 cp mnist.tar.gz {output_path}/mnist.tar.gz
```
## 単一モデルのエンドポイントを使用した TorchServe でのデプロイ
次の例は、[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/) を使用して、[単一モデルのリアルタイム推論エンドポイント](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deployment.html)を作成し、そのモデルをエンドポイントにデプロイし、エンドポイントをテストする方法を示しています。
```
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
predictor_cls = Predictor,
name = "mnist",
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
predictor = model.deploy(instance_type='ml.g4dn.xlarge',
initial_instance_count=1,
endpoint_name = endpoint_name,
serializer=JSONSerializer(),
deserializer=JSONDeserializer())
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(dummy_data)
```
## マルチモデルエンドポイントを使用した TorchServe でのデプロイ
[マルチモデルエンドポイント](https://docs.aws.amazon.com/sagemaker/latest/dg/multi-model-endpoints.html)は、1 つのエンドポイントの背後で多数のモデルをホスティングするためのスケーラブルで費用対効果の高いソリューションです。同じリソースのフリートとサービングコンテナを共有し、すべてのモデルをホストすることで、エンドポイントの使用率を向上させます。また、SageMaker AI はモデルのロードとアンロードを動的に管理し、トラフィックパターンに基づいてリソースをスケーリングするため、デプロイのオーバーヘッドも削減されます。マルチモデルエンドポイントは、処理能力の高速化を必要とする深層学習や生成系 AI モデルに特に役立ちます。
SageMaker AI マルチモデルエンドポイント上で TorchServe を使用すると、SageMaker AI マルチモデルエンドポイントが提供するリソース共有や簡素化されたモデル管理を活用しながら、使い慣れたサービングスタックを使用して開発をスピードアップできます。
次の例は、[Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/) を使用してマルチモデルエンドポイントを作成し、そのモデルをエンドポイントにデプロイし、エンドポイントをテストする方法を示しています。その他の詳細については、この「[ノートブックサンプル](https://github.com/aws/amazon-sagemaker-examples/blob/main/inference/torchserve/mme-gpu/torchserve_multi_model_endpoint.ipynb)」を参照してください。
```
from sagemaker.multidatamodel import MultiDataModel
from sagemaker.model import Model
from sagemaker.predictor import Predictor
# create the single model endpoint and deploy it on SageMaker AI
model = Model(model_data = f'{output_path}/mnist.tar.gz',
image_uri = baseimage,
role = role,
sagemaker_session = smsess)
endpoint_name = 'torchserve-endpoint-' + time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
mme = MultiDataModel(
name = endpoint_name,
model_data_prefix = output_path,
model = model,
sagemaker_session = smsess)
mme.deploy(
initial_instance_count = 1,
instance_type = "ml.g4dn.xlarge",
serializer=sagemaker.serializers.JSONSerializer(),
deserializer=sagemaker.deserializers.JSONDeserializer())
# list models
list(mme.list_models())
# create mnist v2 model artifacts
cp mnist.tar.gz mnistv2.tar.gz
# add mnistv2
mme.add_model(mnistv2.tar.gz)
# list models
list(mme.list_models())
predictor = Predictor(endpoint_name=mme.endpoint_name, sagemaker_session=smsess)
# test the endpoint
import random
import numpy as np
dummy_data = {"inputs": np.random.rand(16, 1, 28, 28).tolist()}
res = predictor.predict(date=dummy_data, target_model="mnist.tar.gz")
```
## メトリクス
TorchServe は、システムレベルとモデルレベルの両方のメトリクスをサポートします。環境変数 `TS_METRICS_MODE` を介して、ログ形式モードまたは Prometheus モードのいずれかでメトリクスを有効にできます。TorchServe セントラルメトリクス設定ファイル `metrics.yaml` を使用して、リクエスト数、レイテンシー、メモリ使用量、GPU 使用率など、追跡するメトリクスのタイプを指定できます。このファイルを参照することで、デプロイされたモデルのパフォーマンスと状態に関するインサイトが得られ、TorchServer サーバーの動作をリアルタイムで効果的にモニタリングできます。詳細については、「[TorchServe メトリクスのドキュメント](https://github.com/pytorch/serve/blob/master/docs/metrics.md#torchserve-metrics)」を参照してください。
Amazon CloudWatch ログフィルターを介して StatsD 形式に似た TorchServe メトリクスログにアクセスできます。TorchServe メトリクスログの例を次に示します。
```
CPUUtilization.Percent:0.0|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
DiskAvailable.Gigabytes:318.0416717529297|#Level:Host|#hostname:my_machine_name,timestamp:1682098185
```
# DJL サービングを使用したモデルのデプロイ
DJL Serving は、高性能のユニバーサルスタンドアロンモデル提供ソリューションです。深層学習モデル、複数のモデル、またはワークフローをとり、HTTP エンドポイントを介して利用できるようにします。
DJL Serving [深層学習コンテナ (DLC)](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) のいずれかを使用して、 AWS上でモデルを提供できます。サポートされているモデルタイプとフレームワークについては、「[DJL Serving GitHub リポジトリ](https://github.com/deepjavalibrary/djl-serving)」を参照してください。
DJL Serving は、モデルを高パフォーマンスでデプロイするのに役立つ多くの特徴量を提供します。
+ 使いやすさ — DJL Serving はほとんどのモデルを変更せずに使用できます。モデルのアーティファクトを持ち込むと、DJL Serving がそれらをホストできます。
+ 複数のデバイスとアクセラレーターのサポート – DJL Serving は CPUs、GPUs、および AWS Inferentia へのモデルのデプロイをサポートしています。
+ パフォーマンス — DJL Serving は 1 台の Java 仮想マシン (JVM) でマルチスレッド推論を実行し、スループットを向上させます。
+ 動的バッチ処理 — DJL Serving は動的バッチ処理をサポートし、スループットを向上させます。
+ 自動スケーリング — DJL Serving は、トラフィックの負荷に応じてワーカーを自動的にスケールアップまたはスケールダウンします。
+ マルチエンジンサポート — DJL Serving は、異なるフレームワーク (PyTorch や TensorFlow など) を使用してモデルを同時にホストできます。
+ アンサンブルモデルとワークフローモデル — DJL Serving は、複数のモデルで構成される複雑なワークフローのデプロイをサポートし、ワークフローの一部を CPU で、他の部分を GPU で実行できます。ワークフロー内のモデルは、さまざまなフレームワークを活用できます。
以下のセクションでは、SageMaker AI で DJL Serving を使用してエンドポイントを設定する方法について説明します。
## 開始方法
開始するには、次の前提条件が整っていることを確認してください。
1. AWS アカウントにアクセスできることを確認します。が IAM ユーザーまたは IAM AWS ロールを介してアカウント AWS CLI にアクセスできるように環境を設定します。IAM ロールの使用をお勧めします。個人アカウントでテストする目的で、以下の管理アクセス許可ポリシーを IAM ロールにアタッチできます。
+ [AmazonEC2ContainerRegistryFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess)
+ [AmazonEC2FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonEC2FullAccess)
+ [AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess)
+ [AmazonS3FullAccess](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/AmazonS3FullAccess)
1. システムに [Docker](https://docs.docker.com/get-docker/) クライアントがセットアップされていることを確認します。
1. Amazon Elastic Container Registry にログインし、以下の環境変数を設定します。
```
export ACCOUNT_ID=
export REGION=
aws ecr get-login-password --region $REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com
```
1. Docker イメージをプルします。
```
docker pull 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118
```
使用可能なすべての DJL Serving コンテナイメージについては、「[大規模モデル推論コンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#large-model-inference-containers)」と「[DJL Serving CPU 推論コンテナ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#djl-cpu-full-inference-containers)」を参照してください。上記のリンクのテーブルからイメージを選択するときは、URL 列の例の AWS リージョンを、現在使用しているリージョンに置き換えます。DLC は、「[使用可能な深層学習コンテナイメージ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md)」ページの上部にある表に記載されているリージョンで使用できます。
## コンテナのカスタマイズ
ベース DLC イメージにパッケージを追加して、コンテナをカスタマイズできます。`763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118` Docker イメージにパッケージを追加したいとします。目的のイメージをベースイメージとして Dockerfile を作成し、必要なパッケージを追加して、そのイメージを Amazon ECR にプッシュする必要があります。
パッケージを作成するには、次のステップを実行します。
1. ベースイメージの Dockerfile に、目的のライブラリまたはパッケージを実行する手順を指定します。
```
FROM 763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.22.1-deepspeed0.9.2-cu118
## add custom packages/libraries
RUN git clone https://github.com/awslabs/amazon-sagemaker-examples
```
1. Dockerfile から Docker イメージをビルドします。Amazon ECR リポジトリ、ベースイメージの名前、およびイメージのタグを指定します。Amazon ECR リポジトリがない場合は、「*Amazon ECR ユーザーガイド*」の「[AWS CLIで Amazon ECR を使用する](https://docs.aws.amazon.com/AmazonECR/latest/userguide/getting-started-cli.html)」を参照して、リポジトリを作成する方法を確認してください。
```
docker build -f Dockerfile -t /:
```
1. Amazon ECR リポジトリに Docker イメージをプッシュします
```
docker push $ACCOUNT_ID.dkr.ecr.$REGION.amazonaws.com/:
```
これで、モデル提供に使用できるカスタマイズされたコンテナイメージがあるはずです。コンテナをカスタマイズするその他の例については、「[Building AWS Deep Learning Containers Custom Images](https://github.com/aws/deep-learning-containers/blob/master/custom_images.md)」を参照してください。
## モデルのアーティファクトの準備
SageMaker AI にモデルをデプロイする前に、モデルアーティファクトを `.tar.gz` ファイルにパッケージ化する必要があります。DJL Serving はアーカイブ内の以下のアーティファクトを受け入れます。
+ モデルチェックポイント: モデルの重みを格納するファイル。
+ `serving.properties`: モデルごとに追加できる設定ファイル。モデルファイルと同じディレクトリに `serving.properties` を置きます。
+ `model.py`: 推論ハンドラーコード。これは Python モードを使用する場合にのみ適用されます。`model.py` を指定しない場合、djl-serving はデフォルトハンドラーの 1 つを使用します。
以下は、`model.tar.gz` 構造の例です。
```
- model_root_dir # root directory
- serving.properties
- model.py # your custom handler file for Python, if you choose not to use the default handlers provided by DJL Serving
- model binary files # used for Java mode, or if you don't want to use option.model_id and option.s3_url for Python mode
```
DJL Serving は、DJL または Python エンジンを搭載した Java エンジンをサポートします。前述のアーティファクトのすべてが必須というわけではありません。必要なアーティファクトは、選択するモードによって異なります。例えば、Python モードでは、`serving.properties` ファイル内で `option.model_id` を指定するだけでよく、LMI コンテナ内のモデルチェックポイントを指定する必要はありません。Java モードでは、モデルチェックポイントをパッケージ化する必要があります。`serving.properties` の設定とさまざまなエンジンの操作方法の詳細については、「[DJL Serving 操作モード](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md)」を参照してください。
## 単一モデルのエンドポイントを使用した DJL Serving でのデプロイ
モデルアーティファクトを準備したら、モデルを SageMaker AI エンドポイントにデプロイできます。このセクションでは、DJL Serving を使用して、単一モデルを、エンドポイントにデプロイする方法について説明します。複数のモデルをデプロイする場合は、このセクションをスキップして 「[マルチモデルのエンドポイントを使用して DJL Serving でデプロイする](#deploy-models-frameworks-djl-mme)」に進んでください。
次の例は、Amazon SageMaker Python SDK を使用してモデルオブジェクトを作成する方法を示します。以下のフィールドを指定する必要があります。
+ `image_uri`: この例で示すように、ベースの DJL Serving イメージの 1 つを取得することも、「[コンテナのカスタマイズ](#deploy-models-frameworks-djl-byoc)」の手順に従って Amazon ECR リポジトリからカスタム Docker イメージを指定することもできます。
+ `model_s3_url`: これは `.tar.gz` ファイルを指す Amazon S3 URI である必要があります。
+ `model_name`: モデルオブジェクトの名前を指定します。
```
import boto3
import sagemaker
from sagemaker.model import Model
from sagemaker import image_uris, get_execution_role
aws_region = "aws-region"
sagemaker_session = sagemaker.Session(boto_session=boto3.Session(region_name=aws_region))
role = get_execution_role()
def create_model(model_name, model_s3_url):
# Get the DJL DeepSpeed image uri
image_uri = image_uris.retrieve(
framework="djl-deepspeed",
region=sagemaker_session.boto_session.region_name,
version="0.20.0"
)
model = Model(
image_uri=image_uri,
model_data=model_s3_url,
role=role,
name=model_name,
sagemaker_session=sagemaker_session,
)
return model
```
## マルチモデルのエンドポイントを使用して DJL Serving でデプロイする
複数のモデルをエンドポイントにデプロイする場合、SageMaker AI はマルチモデルエンドポイントを提供しており、これは、多数のモデルをデプロイするためのスケーラブルで費用対効果の高いソリューションです。DJL Serving は、複数のモデルを同時にロードし、各モデルで同時に推論を実行することもサポートしています。DJL Serving コンテナは SageMaker AI マルチモデルエンドポイント契約に準拠しており、マルチモデルエンドポイントのデプロイに使用できます。
個々のモデルアーティファクトは、前のセクション「[モデルのアーティファクトの準備](#deploy-models-frameworks-djl-artifacts)」で説明したのと同じ方法でパッケージ化する必要があります。モデル固有の設定を `serving.properties` ファイルに、モデル固有の推論ハンドラーコードを `model.py` に設定できます。マルチモデルエンドポイントの場合、モデルは次のように配置する必要があります。
```
root_dir
|-- model_1.tar.gz
|-- model_2.tar.gz
|-- model_3.tar.gz
.
.
.
```
Amazon SageMaker Python SDK は、[MultiDataModel](https://sagemaker.readthedocs.io/en/stable/api/inference/multi_data_model.html) オブジェクトを使用してマルチモデルエンドポイントをインスタンス化します。ルートディレクトリの Amazon S3 URI は、`model_data_prefix` 引数として `MultiDataModel` コンストラクターに渡す必要があります。
DJL Serving には、モデルのメモリ要件を管理するための複数の設定パラメータ (`required_memory_mb` や `reserved_memory_mb` など) も用意されており、[serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties) ファイルでモデルごとに設定できます。これらのパラメータは、メモリ不足エラーをより適切に処理するのに役立ちます。設定可能なすべてのパラメータについては、「[djl-serving での OutofMemory 処理](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/out_of_memory_management.md)」を参照してください。
DJL Serving の自動スケーリング機能により、受信トラフィックに合わせてモデルが適切にスケールされることを簡単に確認できます。デフォルトでは、DJL Serving は、使用可能なハードウェア (CPU コアや GPU デバイスなど) に基づいて、サポート可能なモデルの最大ワーカー数を決定します。モデルごとに下限と上限を設定して、常にトラフィックの最小レベルを処理できるようにし、1 つのモデルが使用可能なリソースをすべて消費しないようにできます。[serving.properties](https://github.com/deepjavalibrary/djl-serving/blob/master/serving/docs/modes.md#servingproperties) ファイルでは、以下のプロパティを設定できます。
+ `gpu.minWorkers`: GPU の最小ワーカー数。
+ `gpu.maxWorkers`: GPU の最大ワーカー数。
+ `cpu.minWorkers`: CPU の最小ワーカー数。
+ `cpu.maxWorkers`: CPU の最大ワーカー数。
DJL サービングコンテナを使用して SageMaker AI にマルチモデルエンドポイントをデプロイする方法のエンドツーエンドの例については、サンプルノートブック「[Multi-model-Inference-Demo.ipynb](https://github.com/deepjavalibrary/djl-demo/blob/master/aws/sagemaker/Multi-Model-Inference-Demo.ipynb)」を参照してください。
# Triton Inference Server によるモデルのデプロイ
[Triton 推論サーバーは](https://github.com/triton-inference-server/server) AI 推論を効率化するオープンソースの推論サービングソフトウェアです。Triton を使用すると、TensorRT、TensorFlow、PyTorch、ONNX、OpenVINO、Python、RAPIDS FIL など、複数の深層学習および機械学習フレームワークで構築されたあらゆるモデルをデプロイできます。
SageMaker AI Triton コンテナは、SageMaker AI ホスティングプラットフォーム上に Triton 推論サーバーをデプロイし、トレーニング済みモデルを本番環境で提供するのに役立ちます。SageMaker AI が動作するさまざまなモードをサポートしています。SageMaker AI で使用可能な Triton 推論サーバーコンテナのリストについては、「[NVIDIA Triton Inference Containers (SM support only)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only)」を参照してください。
エンドツーエンドのノートブックサンプルについては、「[amazon-sagemaker-examples リポジトリ](https://github.com/aws/amazon-sagemaker-examples/tree/main/sagemaker-triton)」を参照することをお勧めします。
## ホスティングモード
Triton コンテナでは、以下の SageMaker AI ホスティングモードがサポートされています。
+ シングルモデルエンドポイント
+ これは SageMaker AI のデフォルトの動作モードです。このモードでは、Triton コンテナは 1 つのモデルまたは 1 つのアンサンブルモデルをロードできます。
+ モデルの名前は、`CreateModel` SageMaker AI API コールの一部であるコンテナ環境のプロパティとして渡す必要があります。モデル名を渡すために使用される環境変数は `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME` です。
+ アンサンブルによる単一モデルエンドポイント
+ Triton 推論サーバーは、パイプラインまたはモデルの DAG (有向非巡回グラフ) であるアンサンブルをサポートします。**アンサンブルは技術的には複数のモデルで構成されますが、デフォルトの単一モデルエンドポイントモードでは、SageMaker AI は*アンサンブル自体* (パイプラインを表すメタモデル) をロードするメインモデルとして扱い、その後に関連するモデルをロードすることができます。
+ モデルをロードするには、アンサンブル自体のモデル名を使用する必要があります。`CreateModel` SageMaker API 呼び出しの一部であるコンテナ環境のプロパティとして渡す必要があります。モデル名を渡すために使用される環境変数は `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME` です。
+ マルチモデルエンドポイント
+ このモードでは、SageMaker AI は 1 つのエンドポイントで複数のモデルを提供できます。このモードを使用するには、`CreateModel` SageMaker API 呼び出しの一部であるコンテナ環境のプロパティとして環境変数 `‘MultiModel’: true` を指定します。
+ デフォルトでは、インスタンスの起動時にモデルはロードされません。特定のモデルに対して推論リクエストを実行するには、`InvokeEndpoint` SageMaker API 呼び出しの `TargetModel` プロパティの引数として、対応するモデルの `*.tar.gz` ファイルを指定します。
+ アンサンブルによるマルチモデルエンドポイント
+ このモードでは、SageMaker AI は、マルチモデルエンドポイントの説明通りに機能します。ただし、SageMaker AI Triton コンテナは複数のアンサンブルモデルをロードできます。つまり、複数のモデルパイプラインを同じインスタンスで実行できます。SageMaker AI はすべてのアンサンブルを 1 つのモデルとして扱い、対応する `*.tar.gz` アーカイブを `TargetModel` として指定することで、各モデルのアンサンブル自体を呼び出すことができます。
+ 動的メモリの `LOAD` および `UNLOAD` 時のメモリ管理を向上するために、アンサンブルサイズを小さくしておくことをお勧めします。
## 推論ペイロードのタイプ
Triton は、推論ペイロードをネットワーク経由で送信する方法として、`json` と `binary+json` (またはバイナリエンコーディングされた json) の 2 つの方法をサポートしています。どちらの場合も JSON ペイロードには、データ型、シェイプ、および実際の推論リクエストテンソルが含まれます。リクエストテンソルはバイナリテンソルである必要があります。
`binary+json` 形式では、Triton がバイナリペイロードを正しく解析できるように、ヘッダーにリクエストメタデータの長さを指定する必要があります。SageMaker AI Triton コンテナでは、`application/vnd.sagemaker-triton.binary+json;json-header-size={}` というカスタム `Content-Type` ヘッダーを使用して行われます。これは、SageMaker AI ではカスタムヘッダーが許可されていないため、スタンドアロンの Triton 推論サーバーで `Inference-Header-Content-Length` ヘッダーを使用するのとは異なります。
## config.pbtxt を使用してモデル設定を設定する
SageMaker AI 上の Triton 推論サーバーでは、各モデルに少なくともモデルの次の設定を指定する `config.pbtxt` ファイルを含める必要があります。
+ `name`: SageMaker AI の外部で実行されるモデルの場合は任意ですが、SageMaker AI 上の Triton で実行されるモデルの名前を常に指定することをお勧めします。
+ [`platform` および/または `backend`](https://github.com/triton-inference-server/backend/blob/main/README.md#backends): モデルのタイプを指定するには、バックエンドの設定が不可欠です。バックエンドによっては、`tensorflow_savedmodel` や ` tensorflow_graphdef` のようにさらに分類されているものもあります。このようなオプションは、`backend` キーに加えて `platform` キーの一部として指定できます。最も一般的なバックエンドは、`tensorrt`、`onnxruntime`、`tensorflow`、`pytorch`、`python`、`dali`、`fil`、`openvino` です。
+ `input`: 入力には `name`、`data_type` および `dims` (シェイプ) の 3 つの属性を指定します。
+ `output`: 出力には `name`、`data_type` および `dims` (シェイプ) の 3 つの属性を指定します。
+ `max_batch_size`: バッチサイズを、Triton がモデルで使用する最大バッチサイズを示す 1 以上の値に設定します。
`config.pbtxt` の設定の詳細については、「Triton の GitHub [リポジトリ](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md)」を参照してください。Triton には、モデルの動作を微調整するための設定がいくつか用意されています。最も一般的で重要な設定オプションは以下のとおりです。
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#instance-groups): インスタンスグループは、指定されたモデルの数と場所を指定するのに役立ちます。これらには `count`、`kind`、および `gpus` (`kind` が `KIND_GPU` の場合に使用) という属性があります。`count` 属性は、ワーカーの数と同等です。通常のモデル提供では、各ワーカーがモデルのコピーを所有します。同様に、Triton では、`count` はデバイスあたりのモデルコピー数を指定します。例えば、`instance_group` タイプが `KIND_CPU` の場合、CPU には `count` 数のモデルのコピーがあります。
**注記**
GPU インスタンスでは、`instance_group` 設定は GPU デバイスごとに適用されます。例えば、モデルをロードする GPU デバイスを明示的に指定しない限り、各 GPU デバイスには `count` 数のモデルのコピーが配置されます。
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/model_configuration.md#dynamic-batcher) と [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#stateful-models): ステートレスモデルには動的バッチ処理が使用され、ステートフルモデル (毎回同じモデルインスタンスにリクエストをルーティングする場合) にはシーケンスバッチ処理が使用されます。バッチ処理スケジューラーではモデルごとのキューが有効になり、バッチ処理の設定によってはスループットの向上に役立ちます。
+ [https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/architecture.md#ensemble-models): アンサンブルモデルは、1 つ以上のモデルの*パイプライン*と、それらのモデル間の入力および出力テンソルの接続を表します。`platform` を `ensemble` と指定することで設定できます。アンサンブル設定はモデルパイプラインの単なる表現です。SageMaker AI では、アンサンブルに含まれるすべてのモデルはアンサンブルモデルの依存モデルとして扱われ、`LoadedModelCount` などの SageMaker AI メトリクスでは単一のモデルとしてカウントされます。
## デフォルトの Triton メトリクスを Amazon CloudWatch に発行する
NVIDIA Triton 推論コンテナは、Triton 推論サーバーで使用されるさまざまなモデルと GPU のメトリクスをポート 8002 (設定可能) で発行します。利用可能なデフォルトのメトリクスの詳細については、「[Triton 推論サーバーメトリクスの GitHub](https://github.com/triton-inference-server/server/blob/main/docs/user_guide/metrics.md)」ページを参照してください。これらのメトリクスは Prometheus 形式で、Prometheus スクレイパー設定を使用してスクレイプすることができます。
バージョン v23.07 以降、SageMaker AI Triton コンテナはいくつかの環境変数を指定することで、Amazon CloudWatch へのこれらのメトリクスの発行をサポ－トしています。Prometheus メトリクスをスクレイプするために、SageMaker AI Triton コンテナは Amazon CloudWatch エージェントを活用します。
メトリクスを収集するために指定する必要がある必須環境変数は次のとおりです。
| 環境変数 | 説明 | 値の例 |
| --- | --- | --- |
| `SAGEMAKER_TRITON_ALLOW_METRICS` | このオプションを指定すると、Triton が Prometheus エンドポイントにメトリクスを発行できるようになります。 | "true" |
| `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | このオプションを指定すると、Amazon CloudWatch にメトリクスを発行するために必要な事前チェックが開始されます。 | "true" |
| `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | このオプションを指定して、メトリクスが書き込まれるロググループを指すようにします。 | 「/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesTest」 |
| `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | このオプションを指定して、メトリクスを表示およびプロットするメトリクス名前空間を指すようにします。 | 「/aws/SageMaker AI/Endpoints/TritonMetrics/SageMakerTwoEnsemblesPublicTest」 |
| `SAGEMAKER_TRITON_METRICS_PORT` | これを 8002 またはその他のポートとして指定します。SageMaker AI が指定されたポートをブロックしていない場合は、そのポートが使用されます。そうでない場合は、ブロックされていない別のポートが自動的に選択されます。 | 「8002」 |
SageMaker AI で Triton を使用してメトリクスを発行する場合、以下の制限に注意してください。
+ C-API と Python バックエンド (v23.05 以降) を使用してカスタムメトリクスを生成することはできますが、Amazon CloudWatch への発行は現在サポートされていません。
+ SageMaker AI マルチモデルエンドポイント (MME) モードでは、各モデル (アンサンブルモデルを除く) は独自のモデルリポジトリにあるかのように扱われるため、Triton はモデル名前空間を有効にする必要がある環境で実行されます。現在、これによりメトリクスに制限が生じています。モデルの名前空間を有効にすると、Triton は異なるアンサンブルに属する同じ名前の 2 つのモデル間のメトリクスを区別しません。回避策として、デプロイされるすべてのモデルに一意の名前を付けます。これにより、CloudWatch でメトリクスを検索するのも簡単になります。
## 環境変数
次の表は、SageMaker AI 上の Triton でサポートされている環境変数の一覧です。
| 環境変数 | 説明 | タイプ | 使用できる値 |
| --- | --- | --- | --- |
| `SAGEMAKER_MULTI_MODEL` | Triton が SageMaker AI のマルチモデルエンドポイントモードで動作できるようにします。 | ブール値 | `true`, `false` |
| `SAGEMAKER_TRITON_DEFAULT_MODEL_NAME` | SageMaker AI 単一モデル (デフォルト) モードでロードするモデルを指定します。アンサンブルモードの場合は、アンサンブル自体の名前を指定します。 | String | ** config.pbtxt で指定 |
| `SAGEMAKER_TRITON_PING_MODE` | `'ready'` は SageMaker AI の単一モデルモードではデフォルトモードで、`'live'` は SageMaker AI のマルチモデルエンドポイントモードではデフォルトモードです。 | String | `ready`, `live` |
| `SAGEMAKER_TRITON_DISABLE_MODEL_NAMESPACING` | SageMaker AI Triton コンテナでは、デフォルトで `true` に設定されています。 | ブール値 | `true`, `false` |
| `SAGEMAKER_BIND_TO_PORT` | SageMaker AI では、デフォルトポートは 8080 です。マルチコンテナのシナリオでは、別のポートにカスタマイズできます。 | String | ** |
| `SAGEMAKER_SAFE_PORT_RANGE` | これは、マルチコンテナモードを使用するときに SageMaker AI プラットフォームによって設定されます。 | String | **–** |
| `SAGEMAKER_TRITON_ALLOW_GRPC` | SageMaker AI は現在 GRPC をサポートしていませんが、カスタムリバースプロキシの前に Triton を使用している場合は GRPC を有効にすることができます。 | ブール値 | `true`, `false` |
| `SAGEMAKER_TRITON_GRPC_PORT` | GRPC のデフォルトポートは 8001 ですが、変更できます。 | String | ** |
| `SAGEMAKER_TRITON_THREAD_COUNT` | デフォルトの HTTP リクエストハンドラーのスレッド数を設定できます。 | String | ** |
| `SAGEMAKER_TRITON_LOG_VERBOSE` | SageMaker AI ではデフォルトで `true` ですが、このオプションを選択的にオフにすることもできます。 | ブール値 | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_INFO` | SageMaker AI のデフォルトでは `false` です。 | ブール値 | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_WARNING` | SageMaker AI のデフォルトでは `false` です。 | ブール値 | `true`, `false` |
| `SAGEMAKER_TRITON_LOG_ERROR` | SageMaker AI のデフォルトでは `false` です。 | ブール値 | `true`, `false` |
| `SAGEMAKER_TRITON_SHM_DEFAULT_BYTE_SIZE` | Python バックエンドの shm サイズをバイト単位で指定します。デフォルト値は 16 MB ですが、これより大きくすることもできます。 | String | ** |
| `SAGEMAKER_TRITON_SHM_GROWTH_BYTE_SIZE` | Python バックエンドの shm 成長サイズをバイト単位で指定します。デフォルト値は 1 MB ですが、増分を増やすこともできます。 | String | ** |
| `SAGEMAKER_TRITON_TENSORFLOW_VERSION` | デフォルト値は `2` です。Triton v23.04 以降、Triton は Tensorflow 2 をサポートしなくなりました。この変数は以前のバージョンで設定できます。 | String | ** |
| `SAGEMAKER_TRITON_MODEL_LOAD_GPU_LIMIT` | モデルのロードに使用される最大 GPU メモリの割合を制限し、残りを推論リクエストに使用できるようにします。 | String | ** |
| `SAGEMAKER_TRITON_ALLOW_METRICS` | SageMaker AI のデフォルトでは `false` です。 | ブール値 | `true`, `false` |
| `SAGEMAKER_TRITON_METRICS_PORT` | デフォルトのポート番号は 8002 です。 | String | ** |
| `SAGEMAKER_TRITON_PUBLISH_METRICS_TO_CLOUDWATCH` | SageMaker AI のデフォルトでは `false` です。この変数を `true` に設定すると、Triton のデフォルトメトリクスを Amazon CloudWatch にプッシュできるようになります。このオプションを有効にすると、メトリクスがアカウントに発行される際の CloudWatch コストはお客様の負担となります。 | ブール値 | `true`, `false` |
| `SAGEMAKER_TRITON_CLOUDWATCH_LOG_GROUP` | CloudWatch へのメトリクスの発行を有効にしている場合は必須です。 | String | ** |
| `SAGEMAKER_TRITON_CLOUDWATCH_METRIC_NAMESPACE` | CloudWatch へのメトリクスの発行を有効にしている場合は必須です。 | String | ** |
| `SAGEMAKER_TRITON_ADDITIONAL_ARGS` | Triton サーバーの起動時に追加の引数を追加します。 | String | ** |
# SageMaker Edge Manager を使用したエッジでのモデルのデプロイ
**警告**
SageMaker Edge Manager は 2024 年 4 月 26 日に廃止されます。引き続きモデルをエッジデバイスにデプロイする方法の詳細については、「[SageMaker エッジマネージャーのサポート終了](edge-eol.md)」を参照してください。
Amazon SageMaker Edge Manager にはエッジデバイスのモデル管理機能が用意されています。そのため、スマートカメラ、ロボット、パーソナルコンピュータ、モバイルデバイスなどのエッジデバイスのフリートで機械学習モデルを最適化、保護、モニタリング、および保守できます。
## Edge Manager を使用する理由
多くの機械学習ユースケースでは、エッジデバイスのフリートで機械学習モデルを実行する必要があります。これにより、リアルタイムでの予測の取得、エンドユーザーのプライバシーの保護、ネットワーク接続コストの削減が実現できます。機械学習向けの、低消費電力のエッジハードウェアの可用性が高まるにつれて、エッジデバイス上で複数の複雑なニューラルネットワークモデルを実行できるようになりました。
しかし、エッジデバイスで機械学習モデルを稼働させることは困難です。クラウドインスタンスとは異なり、コンピューティング性能、メモリ、および接続性が制限されるためです。モデルのデプロイ後は、モデルのドリフトによってモデルの品質が経時的に低下する可能性があるため、モデルを継続的にモニタリングする必要があります。デバイスからデータサンプルを収集し、予測内のスキューを認識するカスタムコードを記述する必要があるため、デバイスフリート全体でモデルをモニタリングすることは困難です。さらに、多くのモデルはアプリケーションにハードコーディングされています。モデルを更新するには、アプリケーションまたはデバイスのファームウェア全体を再構築して更新する必要があります。これにより、稼働が中断される可能性があります。
SageMaker Edge Manager を使用すると、エッジデバイスのフリート全体で機械学習モデルを最適化、実行、モニタリング、更新できます。
## 動作の仕組み
SageMaker Edge Manager ワークフローには、大まかに 5 つの主要コンポーネントがあります。SageMaker Neo を使用したモデルのコンパイル、Neo でコンパイルされたモデルのパッケージ化、デバイスへのモデルデプロイ、SageMaker AI 推論エンジン (Edge Manager エージェント) でのモデルの実行、およびデバイスでのモデルの保守です。
![\[SageMaker Edge Manager ワークフローの 5 つの主要コンポーネント。\]](http://docs.aws.amazon.com/ja_jp/sagemaker/latest/dg/images/smith/smith_overview.png)
SageMaker Edge Manager は SageMaker Neo を使用して、ワンクリックでモデルをターゲットハードウェア用に最適化し、デプロイする前にモデルに暗号的に署名します。SageMaker Edge Manager を使用すると、エッジデバイスからモデル入出力データをサンプリングし、モニタリングと分析のためにクラウドに送信できます。また、SageMaker AI コンソール内でデプロイされたモデルの稼働状況を追跡し、視覚的にレポートするダッシュボードを表示できます。
SageMaker Edge Manager は、以前はクラウドでしか利用できなかった機能をエッジに拡張します。そのため、デベロッパーは Amazon SageMaker Model Monitor を使用してドリフトを検出し、次に SageMaker AI Ground Truth を使用してデータのラベルを変更し、SageMaker AI でモデルを再トレーニングすることで、モデルの品質を継続的に改善できます。
## SageMaker Edge Manager の使い方
SageMaker Edge Manager を初めて使用する方には、次のことをお勧めします。
1. **「[ご利用開始にあたって](https://docs.aws.amazon.com/sagemaker/latest/dg/edge-manager-getting-started.html)」セクションを読む** - このセクションでは、最初にエッジパッケージ化ジョブを設定し、最初のフリートを作成する方法を紹介します。
1. **Edge Manager の Jupyter ノートブックサンプルを調査する** - ノートブックサンプルは、[sagemaker\$1edge\$1manager](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker_edge_manager) フォルダの GitHub リポジトリ [amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) にあります。
# Amazon SageMaker AI Edge Manager を使用した最初のステップ
このガイドでは、デバイスのフリートを登録、デプロイ、管理するために必要なステップを実行する方法と、Amazon SageMaker AI Edge Manager の前提条件を満たす方法を説明します。
**Topics**
+ [セットアップ](edge-getting-started-step1.md)
+ [デプロイのためにモデルを準備する](edge-getting-started-step2.md)
+ [デバイスフリートを登録して認証する](edge-getting-started-step3.md)
+ [Edge Manager をダウンロードしてセットアップする](edge-getting-started-step4.md)
+ [エージェントを実行する](edge-getting-started-step5.md)
# セットアップ
SageMaker Edge Manager を使用してデバイスフリートのモデルを管理する前に、まず SageMaker AI と の両方の IAM ロールを作成する必要があります AWS IoT。また、事前トレーニング済みのモデル、SageMaker Neo のコンパイルジョブの出力、エッジデバイスからの入力データを保存する Amazon S3 バケットを 1 つ以上作成する必要があります。
## にサインアップする AWS アカウント
がない場合は AWS アカウント、次の手順を実行して作成します。
**にサインアップするには AWS アカウント**
1. [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup) を開きます。
1. オンラインの手順に従います。
サインアップ手順の一環として、電話またはテキストメッセージを受け取り、電話キーパッドで検証コードを入力します。
にサインアップすると AWS アカウント、 *AWS アカウントのルートユーザー* が作成されます。ルートユーザーには、アカウントのすべての AWS のサービス とリソースへのアクセス権があります。セキュリティベストプラクティスとして、ユーザーに管理アクセス権を割り当て、[ルートユーザーアクセスが必要なタスク](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)の実行にはルートユーザーのみを使用するようにしてください。
AWS サインアッププロセスが完了すると、 から確認メールが送信されます。[https://aws.amazon.com/](https://aws.amazon.com/) の **[マイアカウント]** をクリックして、いつでもアカウントの現在のアクティビティを表示し、アカウントを管理することができます。
## 管理アクセスを持つユーザーを作成する
にサインアップしたら AWS アカウント、日常的なタスクにルートユーザーを使用しないように AWS アカウントのルートユーザー、 のセキュリティを確保し AWS IAM アイデンティティセンター、 を有効にして管理ユーザーを作成します。
**を保護する AWS アカウントのルートユーザー**
1. **ルートユーザー**を選択し、 AWS アカウント E メールアドレスを入力して、アカウント所有者[AWS マネジメントコンソール](https://console.aws.amazon.com/)として にサインインします。次のページでパスワードを入力します。
ルートユーザーを使用してサインインする方法については、「*AWS サインイン ユーザーガイド*」の「[ルートユーザーとしてサインインする](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)」を参照してください。
1. ルートユーザーの多要素認証 (MFA) を有効にします。
手順については、*IAM* [ユーザーガイドの AWS アカウント 「ルートユーザー (コンソール) の仮想 MFA デバイス](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)を有効にする」を参照してください。
**管理アクセスを持つユーザーを作成する**
1. IAM アイデンティティセンターを有効にします。
手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[AWS IAM アイデンティティセンターの有効化](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)」を参照してください。
1. IAM アイデンティティセンターで、ユーザーに管理アクセスを付与します。
を ID ソース IAM アイデンティティセンターディレクトリ として使用する方法のチュートリアルについては、*AWS IAM アイデンティティセンター 「 ユーザーガイド*」の[「デフォルトを使用してユーザーアクセスを設定する IAM アイデンティティセンターディレクトリ](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)」を参照してください。
**管理アクセス権を持つユーザーとしてサインインする**
+ IAM アイデンティティセンターのユーザーとしてサインインするには、IAM アイデンティティセンターのユーザーの作成時に E メールアドレスに送信されたサインイン URL を使用します。
IAM Identity Center ユーザーを使用してサインインする方法については、*AWS サインイン 「 ユーザーガイド*[」の AWS 「 アクセスポータルにサインイン](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)する」を参照してください。
**追加のユーザーにアクセス権を割り当てる**
1. IAM アイデンティティセンターで、最小特権のアクセス許可を適用するというベストプラクティスに従ったアクセス許可セットを作成します。
手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[アクセス許可セットを作成する](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)」を参照してください。
1. グループにユーザーを割り当て、そのグループにシングルサインオンアクセス権を割り当てます。
手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[グループを追加する](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)」を参照してください。
## ロールとストレージを作成する
SageMaker Edge Manager は Amazon S3 バケット URI にアクセスする必要があります。これが簡単になるように、SageMaker AI を実行でき、Amazon S3 にアクセスする許可を持つ IAM ロールを作成します。このロールを使用すると、SageMaker AI がアカウントで動作し、Amazon S3 バケットにアクセスできます。
IAM ロールを作成するには、IAM コンソール、 AWS SDK for Python (Boto3)、または を使用します AWS CLI。次の例は、IAM ロールを作成し、IAM コンソールで必要なポリシーをアタッチして、Amazon S3 バケットを作成する方法を示しています。
1. **Amazon SageMaker AI 用の IAM ロールを作成する。**
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソールを開きます。
1. IAM コンソールのナビゲーションペインで、**[ロール]**、**[ロールを作成]** の順に選択します。
1. **[信頼できるエンティティの種類の選択]** で、**[AWS サービス]** を選択します。
1. このロールを引き受けることを許可するサービスを選択します。この場合は、**[SageMaker AI]** を選択します。その後、**[Next: Permissions (次へ: アクセス許可)]** を選択します。
+ これにより、Amazon S3、Amazon ECR、CloudWatch Logs などの関連サービスへのアクセス許可を付与する IAM ポリシーが自動的に作成されます。
1. [**次へ: タグ**] を選択します。
1. (オプション) タグをキーバリューのペアとしてアタッチして、メタデータをロールに追加します。IAM でのタグの使用の詳細については、「[IAM リソースのタグ付け](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html)」を参照してください。
1. **[次へ: レビュー]** を選択します。
1. **[Role name]** (ロール名) を入力します。
1. 可能な場合は、ロール名またはロール名のサフィックスを入力します。ロール名は AWS アカウント内で一意である必要があります。大文字と小文字は区別されません。例えば、`PRODROLE` と `prodrole` というロール名を両方作成することはできません。他の AWS リソースはロールを参照する可能性があるため、作成後にロールの名前を編集することはできません。
1. (オプション) [**Role description**] に、新しいロールの説明を入力します。
1. ロール情報を確認し、**ロールの作成** を選択します。
SageMaker AI のロールの ARN を書き留めておきます。これは、SageMaker Neo でのコンパイルジョブの作成と Edge Manager でのパッケージ化ジョブの作成に使います。コンソールを使用してロールの ARN を確認するには、以下を実行します。
1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) に移動します。
1. **[Roles]** (ロール) を選択します。
1. [Search] (検索) フィールドにロール名を入力して、先ほど作成したロールを検索します。
1. ロールを選択します。
1. ロールの ARN は、**[Summary]** (概要) ページの上部にあります。
1. **用の IAM ロールを作成します AWS IoT。**
作成する AWS IoT IAM ロールは、モノのオブジェクトの認可に使われます。また、SageMaker AI クライアントオブジェクトで IAM ロールの ARN を使用して、デバイスフリートを作成し、登録します。
認証情報プロバイダーがデバイスフリート内のデバイスに代わって引き受けるように、 AWS アカウントに IAM ロールを設定します。次に、デバイスが AWS IoT サービスとやり取りすることを許可するポリシーをアタッチします。
SageMaker AI のロールを作成したときと同様に、 AWS IoT プログラムまたは IAM コンソールを使用して のロールを作成します。
1. にサインイン AWS マネジメントコンソール し、[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) で IAM コンソールを開きます。
1. IAM コンソールのナビゲーションペインで、**[ロール]**、**[ロールを作成]** の順に選択します。
1. **[信頼できるエンティティの種類の選択]** で、**[AWS サービス]** を選択します。
1. このロールを引き受けることを許可するサービスを選択します。このケースでは、**[IoT]** を選択します。**[Use Case]** (ユースケース) として**[IoT]** を選択します。
1. **[Next: Permissions]** (次のステップ: 許可) を選択します。
1. [**次へ: タグ**] を選択します。
1. (オプション) タグをキーバリューのペアとしてアタッチして、メタデータをロールに追加します。IAM でのタグの使用の詳細については、「[IAM リソースのタグ付け](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_tags.html)」を参照してください。
1. **[次へ: レビュー]** を選択します。
1. **[Role name]** (ロール名) を入力します。ロール名は「`SageMaker AI`」で始まる必要があります。
1. (オプション) [**Role description**] に、新しいロールの説明を入力します。
1. ロール情報を確認し、**ロールの作成** を選択します。
1. ロールが作成されたら、IAM コンソールで **[Roles]** (ロール) を選択します。**[Search]** (検索) フィールドにロール名を入力して、作成したロールを検索します。
1. ロールを選択します。
1. 次に、**[Attach policies]** (ポリシーをアタッチ) を選択します。
1. **[Search]** (検索) フィールドで `AmazonSageMakerEdgeDeviceFleetPolicy` を検索します。`AmazonSageMakerEdgeDeviceFleetPolicy` を選択します。
1. **[Attach policy]** (ポリシーのアタッチ) を選択します。
1. 信頼関係に次のポリシーステートメントを追加します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {"Service": "credentials.iot.amazonaws.com"},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {"Service": "sagemaker.amazonaws.com"},
"Action": "sts:AssumeRole"
}
]
}
```
------
信頼ポリシーは [JSON ポリシードキュメント](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_grammar)です。ここに、ロールを委任できる、信頼するプリンシパルを定義します。信頼ポリシーの詳細については、「[ロールに関する用語と概念](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html)」を参照してください。
1. AWS IoT ロール ARN を書き留めます。 AWS IoT ロール ARN を使用して、デバイスフリートを作成して登録します。コンソールを使用して IAM ロールの ARN を検索するには、次の手順を実行します。
1. IAM コンソール ([https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)) に移動します。
1. **[ロール]** を選択します。
1. **[Search]** (検索) フィールドにロール名を入力して、作成したロールを検索します。
1. ロールを選択します。
1. ロールの ARN は、[Summary] (概要) ページにあります。
1. **Amazon S3 バケットを作成する。**
SageMaker Neo と Edge Manager は、Amazon S3 バケットからプリコンパイル済みモデルとコンパイル済みモデルにアクセスします。Edge Manager は、デバイスフリートのサンプリングデータを Amazon S3 に保存します。
1. Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. **[バケットを作成]** を選択します。
1. **[Bucket name]** (バケット名) にバケットの名前を入力します。
1. **リージョン**で、バケットを配置する AWS リージョンを選択します。
1. **[Bucket settings for Block Public Access]** (バケットのパブリックアクセスブロック設定) で、バケットに適用する設定を選択します。
1. **[バケットを作成]** を選択します。
Amazon S3 バケットを作成する方法の詳細については、「[Amazon S3 の開始方法](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html)」を参照してください。
# デプロイのためにモデルを準備する
このセクションでは、SageMaker AI と AWS IoT クライアントオブジェクトの作成、事前トレーニング済みの機械学習モデルのダウンロード、Amazon S3 バケットへのモデルのアップロード、SageMaker Neo を使用したターゲットデバイスのモデルのコンパイル、 Edge Manager エージェントでデプロイできるようにモデルをパッケージ化します。
1. **ライブラリをインポートし、クライアントオブジェクトを作成します。**
このチュートリアルでは AWS SDK for Python (Boto3) 、 を使用して、SageMaker AI、Amazon S3、および とやり取りするクライアントを作成します AWS IoT。
次の例に示すように、Boto3 をインポートし、リージョンを指定し、必要なクライアントオブジェクトを初期化します。
```
import boto3
import json
import time
AWS_REGION = 'us-west-2'# Specify your Region
bucket = 'bucket-name'
sagemaker_client = boto3.client('sagemaker', region_name=AWS_REGION)
iot_client = boto3.client('iot', region_name=AWS_REGION)
```
変数を定義し、SageMaker AI と AWS IoT 向けに作成したロール ARN を文字列として割り当てます。
```
# Replace with the role ARN you created for SageMaker
sagemaker_role_arn = "arn:aws:iam:::role/*"
# Replace with the role ARN you created for AWS IoT.
# Note: The name must start with 'SageMaker'
iot_role_arn = "arn:aws:iam:::role/SageMaker*"
```
1. **機械学習モデルをトレーニングする。**
SageMaker AI を使用して機械学習モデルをトレーニングする方法の詳細については、「[Amazon SageMaker でモデルをトレーニングする](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html)」を参照してください。任意で、ローカルでトレーニングしたモデルを Amazon S3 URI バケットに直接アップロードできます。
まだモデルがない場合は、このチュートリアルの次のステップの事前トレーニング済みモデルを使用できます。たとえば、TensorFlow フレームワークによる MobileNet V2 モデルを保存することができます。MobileNet V2 はモバイルアプリケーション向けに最適化された画像分類モデルです。MobileNet V2 の詳細については、[MobileNet GitHub README](https://github.com/tensorflow/models/tree/master/research/slim/nets/mobilenet) を参照してください。
Jupyter Notebook に以下を入力し、事前トレーニング済みの MobileNet V2 モデルを保存します。
```
# Save the MobileNet V2 model to local storage
import tensorflow as tf
model = tf.keras.applications.MobileNetV2()
model.save(“mobilenet_v2.h5”)
```
**注記**
TensorFlow がインストールされていない場合は、`pip install tensorflow=2.4` を実行してインストールしてください。
このチュートリアルでは、TensorFlow バージョン 2.4 以下を使用します。
モデルは `mobilenet_v2.h5` ファイルに保存されます。モデルは、SageMaker Neo を使用してコンパイルしてからパッケージ化する必要があります。「[サポートされているフレームワーク、デバイス、システム、アーキテクチャ](neo-supported-devices-edge.md)」で、TensorFlow (または選択した他のフレームワーク) のバージョンが現在 SageMaker Neo でサポートされているかどうかを確認してください。
SageMaker Neo では、モデルを圧縮された tar ファイルとして保存する必要があります。圧縮された tar ファイル (\$1.tar.gz) として再パッケージ化します。
```
# Package MobileNet V2 model into a TAR file
import tarfile
tarfile_name='mobilenet-v2.tar.gz'
with tarfile.open(tarfile_name, mode='w:gz') as archive:
archive.add('mobilenet-v2.h5')
```
1. **ファイルを Amazon S3 にアップロードする。**
機械学習モデルを作成したら、それをAmazon S3 バケットに保存します。次の例では、 AWS CLI コマンドを使用して、モデルと呼ばれるディレクトリで以前に作成した Amazon S3 バケットに*モデル* をアップロードします。Jupyter ノートブックに次を入力します。
```
!aws s3 cp mobilenet-v2.tar.gz s3://{bucket}/models/
```
1. **SageMaker Neo でモデルをコンパイルする。**
SageMaker Neo を使用して、機械学習モデルをエッジデバイス用にコンパイルします。トレーニング済みモデルを保存した Amazon S3 バケット URI、モデルのトレーニングに使用した機械学習フレームワーク、モデルの入力の形状、ターゲットデバイスを把握している必要があります。
MobileNet V2 モデルについては次を使います。
```
framework = 'tensorflow'
target_device = 'jetson_nano'
data_shape = '{"data":[1,3,224,224]}'
```
SageMaker Neo では、使用する深層学習フレームワークに応じて、モデルが特定の入力形状と形式になっている必要があります。モデルを保存する方法の詳細については、「[SageMaker Neo が想定する入力データの形状](neo-compilation-preparing-model.md#neo-job-compilation-expected-inputs)」を参照してください。Neo がサポートするデバイスおよびフレームワークの詳細については、「[サポートされているフレームワーク、デバイス、システム、アーキテクチャ](neo-supported-devices-edge.md)」を参照してください。
`CreateCompilationJob` API を使用して、SageMaker Neo でコンパイルジョブを作成します。コンパイルジョブの名前、SageMaker AI ロールの ARN、モデルが保存されている Amazon S3 URI、モデルの入力形状、フレームワークの名前、コンパイルしたモデルを保存する Amazon S3 URI、ターゲットエッジデバイスを指定します。
```
# Specify the path where your model is stored
model_directory = 'models'
s3_model_uri = 's3://{}/{}/{}'.format(bucket, model_directory, tarfile_name)
# Store compiled model in S3 within the 'compiled-models' directory
compilation_output_dir = 'compiled-models'
s3_output_location = 's3://{}/{}/'.format(bucket, compilation_output_dir)
# Give your compilation job a name
compilation_job_name = 'getting-started-demo'
sagemaker_client.create_compilation_job(CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
InputConfig={
'S3Uri': s3_model_uri,
'DataInputConfig': data_shape,
'Framework' : framework.upper()},
OutputConfig={
'S3OutputLocation': s3_output_location,
'TargetDevice': target_device},
StoppingCondition={'MaxRuntimeInSeconds': 900})
```
1. **コンパイルしたモデルをパッケージ化する。**
パッケージ化ジョブは SageMaker Neo でコンパイルされたモデルを使用します。また、推論エンジンである Edge Manager エージェントを使用して、モデルのデプロイに必要な変更を加えます。モデルをパッケージ化するには、`create_edge_packaging` API または SageMaker AI コンソールを使用してエッジパッケージ化ジョブを作成します。
Neo コンパイルジョブに使用した名前、パッケージ化ジョブの名前、ロール ARN ([セットアップ](edge-getting-started-step1.md)セクションを参照してください)、モデルの名前、モデルバージョン、およびパッケージ化ジョブの出力先の Amazon S3 バケット URI を指定する必要があります。Edge Manager のパッケージ化ジョブ名では、大文字と小文字が区別されます。以下は、API を使用してパッケージ化ジョブを作成する方法の例です。
```
edge_packaging_name='edge-packaging-demo'
model_name="sample-model"
model_version="1.1"
```
パッケージ化されたモデルを保存する Amazon S3 URI を定義します。
```
# Output directory where you want to store the output of the packaging job
packaging_output_dir = 'packaged_models'
packaging_s3_output = 's3://{}/{}'.format(bucket, packaging_output_dir)
```
`CreateEdgePackagingJob` を使用して、Neo でコンパイルされたモデルをパッケージ化します。エッジパッケージ化ジョブの名前と、コンパイルジョブの名前 (この例では、変数 `compilation_job_name` に保存されています) を指定します。また、モデルの名前、モデルのバージョン (使用しているモデルバージョンの追跡に役立ちます)、SageMaker AI がパッケージ化済みモデルを保存する S3 URI を指定します。
```
sagemaker_client.create_edge_packaging_job(
EdgePackagingJobName=edge_packaging_name,
CompilationJobName=compilation_job_name,
RoleArn=sagemaker_role_arn,
ModelName=model_name,
ModelVersion=model_version,
OutputConfig={
"S3OutputLocation": packaging_s3_output
}
)
```
# デバイスフリートを登録して認証する
このセクションでは、 AWS IoT モノのオブジェクトの作成、デバイスフリートの作成、デバイスフリートの登録を行い、クラウドとのやり取り、デバイスを認証する X.509 証明書の作成 AWS IoT Core、フリートの作成時に AWS IoT 生成されたロールエイリアスの関連付け、認証情報プロバイダーの AWS アカウント固有のエンドポイントの取得、公式の Amazon ルート CA ファイルの取得、Amazon CA ファイルの Amazon S3 へのアップロードを行います。
1. ** AWS IoT モノを作成します。**
SageMaker Edge Manager は、 AWS IoT Core サービスを活用して、 AWS クラウド内のエッジデバイスとエンドポイント間の接続を容易にします。Edge Manager と連携するようにデバイスをセットアップした後、既存の AWS IoT 機能を活用できます。
デバイスを に接続するには AWS IoT、 AWS IoT *オブジェクト*を作成し、クライアント証明書を作成して AWS IoT に登録し、デバイスの IAM ロールを作成して設定する必要があります。
まず、Boto3 で前に作成した AWS IoT クライアント (`iot_client`) を使用して AWS IoT モノのオブジェクトを作成します。以下の例では、2 つのモノオブジェクトを作成する方法を示しています。
```
iot_thing_name = 'sample-device'
iot_thing_type = 'getting-started-demo'
iot_client.create_thing_type(
thingTypeName=iot_thing_type
)
# Create an AWS IoT thing objects
iot_client.create_thing(
thingName=iot_thing_name,
thingTypeName=iot_thing_type
)
```
1. **デバイスフリートを作成する。**
前のステップで定義した SageMaker AI クライアントオブジェクトを使用してデバイスフリートを作成します。SageMaker AI コンソールを使用してデバイスフリートを作成することもできます。
```
import time
device_fleet_name="demo-device-fleet" + str(time.time()).split('.')[0]
device_name="sagemaker-edge-demo-device" + str(time.time()).split('.')[0]
```
IoT ロールの ARN を指定します。これにより、 はデバイスに一時的な認証情報 AWS IoT を付与できます。
```
device_model_directory='device_output'
s3_device_fleet_output = 's3://{}/{}'.format(bucket, device_model_directory)
sagemaker_client.create_device_fleet(
DeviceFleetName=device_fleet_name,
RoleArn=iot_role_arn, # IoT Role ARN specified in previous step
OutputConfig={
'S3OutputLocation': s3_device_fleet_output
}
)
```
AWS IoT ロールエイリアスは、デバイスフリートを作成するときに作成されます。このロールエイリアスは、後のステップで `iot_client` オブジェクト AWS IoT を使用することに関連付けられます。
1. **デバイスフリートを登録する。**
クラウドと通信するには、SageMaker Edge Manager を使用してデバイスを登録する必要があります。この例では、作成したフリートにデバイスを 1 つ登録します。デバイスを登録するには、次の例に示すように、デバイス名と AWS IoT モノオブジェクトの名前を指定する必要があります。
```
# Device name should be 36 characters
device_name = "sagemaker-edge-demo-device" + str(time.time()).split('.')[0]
sagemaker_client.register_devices(
DeviceFleetName=device_fleet_name,
Devices=[
{
"DeviceName": device_name,
"IotThingName": iot_thing_name
}
]
)
```
1. **X.509 証明書を作成する。**
AWS IoT モノのオブジェクトを作成したら、モノのオブジェクトの X.509 デバイス証明書を作成する必要があります。証明書により、 AWS IoT Coreにデバイスを認証できます。
以下を使用して、前に定義した AWS IoT クライアント (`iot_client`) を使用してプライベートキー、パブリックキー、および X.509 証明書ファイルを作成します。
```
# Creates a 2048-bit RSA key pair and issues an X.509 # certificate
# using the issued public key.
create_cert = iot_client.create_keys_and_certificate(
setAsActive=True
)
# Get certificate from dictionary object and save in its own
with open('./device.pem.crt', 'w') as f:
for line in create_cert['certificatePem'].split('\n'):
f.write(line)
f.write('\n')
# Get private key from dictionary object and save in its own
with open('./private.pem.key', 'w') as f:
for line in create_cert['keyPair']['PrivateKey'].split('\n'):
f.write(line)
f.write('\n')
# Get a private key from dictionary object and save in its own
with open('./public.pem.key', 'w') as f:
for line in create_cert['keyPair']['PublicKey'].split('\n'):
f.write(line)
f.write('\n')
```
1. **ロールエイリアスを関連付けます AWS IoT。**
SageMaker AI (`sagemaker_client.create_device_fleet()`) でデバイスフリートを作成すると、ロールエイリアスが自動的に生成されます。 AWS IoT ロールエイリアスは、接続されたデバイスが X.509 証明書 AWS IoT を使用して を認証し、ロールエイリアスに関連付けられた AWS IoT IAM ロールから有効期間の短い AWS 認証情報を取得するメカニズムを提供します。ロールエイリアスを使用することで、デバイスを更新しなくてもロールを変更できます。`DescribeDeviceFleet` を使用して、ロールのエイリアス名と ARN を取得します。
```
# Print Amazon Resource Name (ARN) and alias that has access
# to AWS Internet of Things (IoT).
sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)
# Store iot role alias string in a variable
# Grabs role ARN
full_role_alias_name = sagemaker_client.describe_device_fleet(DeviceFleetName=device_fleet_name)['IotRoleAlias']
start_index = full_role_alias_name.find('SageMaker') # Find beginning of role name
role_alias_name = full_role_alias_name[start_index:]
```
を使用して`iot_client`、デバイスフリートの作成によって生成されたロールエイリアスの関連付けを容易にします AWS IoT。
```
role_alias = iot_client.describe_role_alias(
roleAlias=role_alias_name)
```
IAM ロールエイリアスの詳細については、「[ロールエイリアスが未使用サービスへのアクセスを許可します](https://docs.aws.amazon.com/iot/latest/developerguide/audit-chk-role-alias-unused-svcs.html)」を参照してください。
デバイスの認証を成功させるために、 AWS IoT 以前に証明書を作成して に登録しました。次は、ポリシーを作成し、それを証明書にアタッチして、セキュリティトークンのリクエストを認可する必要があります。
```
alias_policy = {
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": role_alias['roleAliasDescription']['roleAliasArn']
}
}
policy_name = 'aliaspolicy-'+ str(time.time()).split('.')[0]
aliaspolicy = iot_client.create_policy(policyName=policy_name,
policyDocument=json.dumps(alias_policy))
# Attach policy
iot_client.attach_policy(policyName=policy_name,
target=create_cert['certificateArn'])
```
1. **認証情報プロバイダーの AWS アカウント固有のエンドポイントを取得します。**
エッジデバイスには、認証情報を継承するエンドポイントが必要です。認証情報プロバイダー向けの AWS アカウント固有のエンドポイントを取得します。
```
# Get the unique endpoint specific to your AWS account that is making the call.
iot_endpoint = iot_client.describe_endpoint(
endpointType='iot:CredentialProvider'
)
endpoint="https://{}/role-aliases/{}/credentials".format(iot_endpoint['endpointAddress'],role_alias_name)
```
1. **公式の Amazon ルート CA ファイルを取得して、Amazon S3 バケットにアップロードする。**
Jupyter Notebook で以下を使用するか AWS CLI (ターミナルを使用する場合は、「！」マジック関数を削除します）。
```
!wget https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
エンドポイントを使用して、セキュリティトークンを返す HTTPS リクエストを認証情報プロバイダーに作成します。次のコマンド例では、`curl` を使用していますが、任意の HTTP クライアントを使用できます。
```
!curl --cert device.pem.crt --key private.pem.key --cacert AmazonRootCA1.pem $endpoint
```
証明書の検証が完了したら、Amazon S3 バケット URI にキーと証明書をアップロードします。
```
!aws s3 cp private.pem.key s3://{bucket}/authorization-files/
!aws s3 cp device.pem.crt s3://{bucket}/authorization-files/
!aws s3 cp AmazonRootCA1.pem s3://{bucket}/authorization-files/
```
キーと証明書を他のディレクトリに移動して、作業ディレクトリをクリーンアップします。
```
# Optional - Clean up working directory
!mkdir authorization-files
!mv private.pem.key device.pem.crt AmazonRootCA1.pem authorization-files/
```
# Edge Manager をダウンロードしてセットアップする
Edge Manager エージェントはエッジデバイス用の推論エンジンです。エージェントを使用して、エッジデバイスにロードされたモデルで予測を行います。エージェントはモデルのメトリクスを収集し、特定の間隔でデータをキャプチャします。
このセクションでは、エージェントを使用してデバイスを設定します。これを行うには、最初に、リリースバケットからリリースアーティファクトと署名ルート証明書をローカルマシンにコピーします。リリースアーティファクトを解凍したら、それを Amazon S3 にアップロードします。次に、エージェントの設定ファイルを定義し、保存します。コピーアンドペーストできるテンプレートが用意されています。最後に、デバイスにリリースアーティファクト、設定ファイル、認証情報をコピーします。
1. **SageMaker Edge Manager エージェントをダウンロードする。**
エージェントは、サポート対象のオペレーティングシステム向けに、バイナリ形式でリリースされます。この例では、Linux オペレーティングシステムを使用し、ARM64 アーキテクチャを持つ Jetson Nano で推論が実行されます。サポート対象のデバイスが使用するオペレーティングシステムとアーキテクチャの詳細については、「[サポートされているデバイス、チップアーキテクチャ、システム](neo-supported-devices-edge-devices.md)」を参照してください。
us-west-2 リージョンの SageMaker Edge Manager リリースバケットから最新バージョンのバイナリを取得します。
```
!aws s3 ls s3://sagemaker-edge-release-store-us-west-2-linux-armv8/Releases/ | sort -r
```
これにより、バージョン別に並べ替えられたリリースアーティファクトが返されます。
```
PRE 1.20210512.96da6cc/
PRE 1.20210305.a4bc999/
PRE 1.20201218.81f481f/
PRE 1.20201207.02d0e97/
```
バージョンの形式は `..` のようになっています。これは、3 つのコンポーネントから構成されています。
+ ``: リリースのバージョン。現在、リリースバージョンは `1` に設定されています。
+ ``: リリースアーティファクトのタイムスタンプ。
+ : リリースのビルド元のリポジトリコミット ID。
圧縮された tar ファイルを、ローカルにコピーするか、デバイスに直接コピーします。次の例は、このドキュメントを公開した時点で最新のリリースアーティファクトをコピーする方法を示しています。
```
!aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Releases/1.20201218.81f481f/1.20201218.81f481f.tgz ./
```
アーティファクトを入手したら、圧縮された tar ファイルを解凍します。以下の例では、tar ファイルを解凍し、それを `agent_demo` ディレクトリに保存しています。
```
!mkdir agent_demo
!tar -xvzf 1.20201218.81f481f.tgz -C ./agent_demo
```
Amazon S3 バケットにエージェントのリリースアーティファクトをアップロードします。次のサンプルコードは、`agent_demo` 内のコンテンツをコピーし、Amazon S3 バケットの `agent_demo` ディレクトリにアップロードします。
```
!aws s3 cp --recursive ./agent_demo s3://{bucket}/agent_demo
```
リリースバケットの署名ルート証明書も必要です。
```
!aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Certificates/us-west-2/us-west-2.pem ./
```
この署名ルート証明書を Amazon S3 バケットにアップロードします。
```
!aws s3 cp us-west-2.pem s3://{bucket}/authorization-files/
```
1. **SageMaker Edge Manager エージェントの設定ファイルを作成する。**
まず、エージェントの設定ファイルを次のように定義します。
```
sagemaker_edge_config = {
"sagemaker_edge_core_device_name": "device_name",
"sagemaker_edge_core_device_fleet_name": "device_fleet_name",
"sagemaker_edge_core_capture_data_buffer_size": 30,
"sagemaker_edge_core_capture_data_push_period_seconds": 4,
"sagemaker_edge_core_folder_prefix": "demo_capture",
"sagemaker_edge_core_region": "us-west-2",
"sagemaker_edge_core_root_certs_path": "/agent_demo/certificates",
"sagemaker_edge_provider_aws_ca_cert_file": "/agent_demo/iot-credentials/AmazonRootCA1.pem",
"sagemaker_edge_provider_aws_cert_file": "/agent_demo/iot-credentials/device.pem.crt",
"sagemaker_edge_provider_aws_cert_pk_file": "/agent_demo/iot-credentials/private.pem.key",
"sagemaker_edge_provider_aws_iot_cred_endpoint": "endpoint",
"sagemaker_edge_provider_provider": "Aws",
"sagemaker_edge_provider_s3_bucket_name": bucket,
"sagemaker_edge_core_capture_data_destination": "Cloud"
}
```
以下に置き換えます:
+ `"device_name"` - デバイスの名前 (この文字列は、前のステップで `device_name` という名前の変数に保存されました)。
+ `"device_fleet_name`" - デバイスフリートの名前 (この文字列は、前のステップで `device_fleet_name` という名前の変数に保存されました)。
+ `"endpoint"` 認証情報プロバイダーの AWS アカウント固有のエンドポイント (この文字列は、前のステップで という名前の変数に保存されました`endpoint`)。
次に、設定ファイルを JSON ファイルとして保存します。
```
edge_config_file = open("sagemaker_edge_config.json", "w")
json.dump(sagemaker_edge_config, edge_config_file, indent = 6)
edge_config_file.close()
```
Amazon S3 バケットに設定ファイルをアップロードします。
```
!aws s3 cp sagemaker_edge_config.json s3://{bucket}/
```
1. **デバイスにリリースアーティファクト、設定ファイル、認証情報をコピーする。**
次の手順は、エッジデバイスで実行します。
**注記**
まず、 AWS CLI エッジデバイスに Python AWS SDK for Python (Boto3)、、 をインストールする必要があります。
デバイスのターミナルを開きます。リリースアーティファクト、認証情報、設定ファイルを保存するフォルダを作成します。
```
mkdir agent_demo
cd agent_demo
```
デバイスに、Amazon S3 バケットに保存したリリースアーティファクトの内容をコピーします。
```
# Copy release artifacts
aws s3 cp s3:///agent_demo/ ./ --recursive
```
(リリースアーティファクトの内容は、前のステップでディレクトリ `agent_demo` に保存されました)。`