サポート終了通知: 2026 年 10 月 7 日、 AWS はサポートを終了します AWS IoT Greengrass Version 1。2026 年 10 月 7 日以降、 AWS IoT Greengrass V1 リソースにアクセスできなくなります。詳細については、[「 からの移行 AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html)」を参照してください。
翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# 機械学習の推論を実行する
この機能は AWS IoT Greengrass Core v1.6 以降で使用できます。
を使用すると AWS IoT Greengrass、クラウドでトレーニングされたモデルを使用して、ローカルに生成されたデータのエッジで機械学習 (ML) 推論を実行できます。ローカル推論の実行により低レイテンシーとコスト節約のメリットを得ながら、モデルのトレーニングと複雑な処理にクラウドコンピューティングの処理能力を活用できます。
ローカル推論の実行を開始するには、「[を使用して機械学習推論を設定する方法 AWS マネジメントコンソール](ml-console.md)」を参照してください。
## ML AWS IoT Greengrass 推論の仕組み
推論モデルは、任意の場所でトレーニングし、Greengrass グループに機械学習リソースとしてローカルにデプロイした後、Greengrass Lambda 関数からアクセスできるようになります。たとえば、[SageMaker AI ](https://console.aws.amazon.com/sagemaker)で深層学習モデルを構築およびトレーニングし、Greengrass コアにデプロイできます。その後、Lambda 関数はローカルモデルを使用して、接続されたデバイスで推論を実行し、新しいトレーニングデータをクラウドに送り返すことができます。
次の図は、ML AWS IoT Greengrass 推論ワークフローを示しています。
![\[機械学習ワークフローのコンポーネント、およびコアデバイス ( AWS IoT Greengrass サービス) とクラウドトレーニング済みモデルとの間の情報フロー。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/ml-inference/diagram-ml-overview.png)
AWS IoT Greengrass ML 推論は、以下を含む ML ワークフローの各ステップを簡素化します。
+ ML フレームワークのプロトタイプを構築し、デプロイする。
+ クラウドトレーニング済みモデルにアクセスし、それらのモデルを Greengrass コアデバイスにデプロイする。
+ [ローカルリソース](access-local-resources.md)であるハードウェアアクセラレーター (GPU や FPGA など) にアクセスできる推論アプリケーションを作成する。
## 機械学習リソース
機械学習リソースは、 AWS IoT Greengrass コアにデプロイされるクラウドトレーニングされた推論モデルを表します。機械学習リソースをデプロイするには、まず Greengrass グループに追加し、グループ内の Lambda 関数がそれらのリソースにアクセスできる方法を定義します。グループのデプロイ中、 はクラウドからソースモデルパッケージ AWS IoT Greengrass を取得し、Lambda ランタイム名前空間内のディレクトリに抽出します。その後、Greengrass Lambda 関数によって、ローカルにデプロイしたモデルを使用して推論が実行されるようになります。
ローカルにデプロイしたモデルを更新するには、まず機械学習リソースに対応するソースモデル (クラウド内) を更新してから、そのグループをデプロイします。デプロイ中、 AWS IoT Greengrass によってソースの変更が確認されます。変更が検出されると、 はローカルモデル AWS IoT Greengrass を更新します。
### サポートされているモデルソース
AWS IoT Greengrass は、機械学習リソースの SageMaker AI および Amazon S3 モデルソースをサポートしています。
モデルソースには、以下の要件が適用されます。
+ SageMaker AI および Amazon S3 モデルソースを保存する S3 バケットは、SSE-C を使用して暗号化しないでください。 Amazon S3 サーバー側の暗号化を使用するバケットの場合、 AWS IoT Greengrass ML 推論は現在 SSE-S3 または SSE-KMS 暗号化オプションのみをサポートしています。サーバー側の暗号化の詳細については、「Amazon Simple Storage Service ユーザーガイド」の「[サーバー側の暗号化を使用したデータ保護](https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html)」を参照してください。
+ SageMaker AI および Amazon S3 モデルソースを保存する S3 バケットの名前にピリオド () を含めることはできません`.`。 SageMaker 詳細については、「Amazon Simple Storage Service ユーザーガイド」の[バケット命名規則](https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html#bucketnamingrules)で、SSL で仮想ホスト型バケットの使用に関するルールを参照してください。
+ サービスレベルの AWS リージョン サポートは、 [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)と [SageMaker AI ](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html)の両方で利用できる必要があります。現在、 AWS IoT Greengrass は次のリージョンで SageMaker AI モデルをサポートしています。
+ 米国東部(オハイオ)
+ 米国東部 (バージニア北部)
+ 米国西部 (オレゴン)
+ アジアパシフィック (ムンバイ)
+ アジアパシフィック (ソウル)
+ アジアパシフィック (シンガポール)
+ アジアパシフィック (シドニー)
+ アジアパシフィック (東京)
+ 欧州 (フランクフルト)
+ 欧州 (アイルランド)
+ 欧州 (ロンドン)
+ AWS IoT Greengrass 次のセクションで説明するように、 にはモデルソースに対する`read`アクセス許可が必要です。
**SageMaker AI**
AWS IoT Greengrass は、SageMaker AI トレーニングジョブとして保存されるモデルをサポートします。SageMaker AI は、組み込みアルゴリズムまたはカスタムアルゴリズムを使用してモデルを構築およびトレーニングするために使用できるフルマネージド型の ML サービスです。詳細については、[SageMaker AI デベロッパーガイド」の「SageMaker AI とは](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)」を参照してください。 *SageMaker *
という名前の[バケットを作成して](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-config-permissions.html) SageMaker AI 環境を設定した場合`sagemaker`、 AWS IoT Greengrass には SageMaker AI トレーニングジョブにアクセスするための十分なアクセス許可があります。`AWSGreengrassResourceAccessRolePolicy` 管理ポリシーは、名前に文字列 `sagemaker` が含まれるバケットへのアクセスを許可します。このポリシーは [Greengrass サービスのロール](service-role.md)にアタッチされます。
それ以外の場合は、トレーニングジョブが保存されているバケットにアクセス許可を付与 AWS IoT Greengrass `read`する必要があります。そのためには、サービスロールに以下のインラインポリシーを埋め込みます。複数のバケット ARN を含めることができます。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
**Amazon S3**
AWS IoT Greengrass は、Amazon S3 に `tar.gz`または `.zip` ファイルとして保存されているモデルをサポートします。
AWS IoT Greengrass が Amazon S3 バケットに保存されているモデルにアクセスできるようにするには、****次のいずれかを実行してバケットにアクセスするためのアクセス AWS IoT Greengrass `read`許可を付与する必要があります。
+ 名前に `greengrass` が含まれるバケットにモデルを保存します。
`AWSGreengrassResourceAccessRolePolicy` 管理ポリシーは、名前に文字列 `greengrass` が含まれるバケットへのアクセスを許可します。このポリシーは [Greengrass サービスのロール](service-role.md)にアタッチされます。
+ Greengrass サービスロールにインラインポリシーを埋め込みます。
バケット名に `greengrass` が含まれない場合は、サービスロールに以下のインラインポリシーを追加します。複数のバケット ARN を含めることができます。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
------
詳細については、「IAM ユーザーガイド」の「[インラインポリシーの埋め込み](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console)」を参照してください。
## 要件
機械学習リソースの作成と使用には、以下の要件が適用されます。
+ AWS IoT Greengrass Core v1.6 以降を使用している必要があります。
+ ユーザー定義 Lambda 関数は、リソースに対して `read` または `read and write` オペレーションを実行できます。他のオペレーションに対するアクセス許可はありません。関連する Lambda 関数のコンテナ化モードによって、アクセス権限の設定方法が決まります。詳細については、「[Lambda 関数から機械学習リソースにアクセスする](access-ml-resources.md)」を参照してください。
+ コアデバイスのオペレーティングシステム上のリソースの完全パスを指定することが必要です。
+ リソース名または ID の最大長は 128 文字で、パターン `[a-zA-Z0-9:_-]+` を使用する必要があります。
## ML 推論用のランタイムとライブラリ
では、次の ML ランタイムとライブラリを使用できます AWS IoT Greengrass。
+ [Amazon SageMaker Neo Deep Learning ランタイム](#dlc-optimize-info)
+ Apache MXNet
+ TensorFlow
これらのランタイムとライブラリは、NVIDIA Jetson TX2、Intel Atom、および Raspberry Pi プラットフォームにインストールできます。ダウンロード情報については、「[サポートされている機械学習ランタイムおよびライブラリ](what-is-gg.md#ml-runtimes-libs)」を参照してください。コアデバイスに直接インストールできます。
互換性と制限については、必ず以下の情報を参照してください。
### SageMaker AI Neo 深層学習ランタイム
SageMaker AI Neo 深層学習ランタイムを使用して、 AWS IoT Greengrass デバイスで最適化された機械学習モデルで推論を実行できます。これらのモデルは、機械学習の推論予測速度を向上させるために SageMaker AI Neo 深層学習コンパイラを使用して最適化されています。SageMaker AI でのモデル最適化の詳細については、[SageMaker AI Neo ドキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html)を参照してください。
**注記**
現在、特定のアマゾン ウェブ サービスリージョンでのみ Neo 深層学習コンパイラを使用して機械学習モデルを最適化できます。ただし、 AWS リージョン AWS IoT Greengrass コアがサポートされている各 で最適化されたモデルで Neo 深層学習ランタイムを使用できます。詳細については、「[最適化された機械学習推論を設定する方法](ml-dlc-console.md)」を参照してください。
### MXNet のバージョニング
Apache MXNet は現在、下位互換性を保証していないため、フレームワークの新しいバージョンを使用してトレーニングするモデルは、フレームワークの以前のバージョンでは正しく動作しないことがあります。モデルトレーニング段階とモデル提供段階との間で競合を回避し、一貫したエンドツーエンドエクスペリエンスを実現するには、両方の段階で同じバージョンの MXNet フレームワークを使用します。
### Raspberry Pi の MXNet
ローカル MXNet モデルにアクセスする Greengrass Lambda 関数では、以下の環境変数が設定される必要があります。
```
MXNET_ENGINE_TYPE=NativeEngine
```
関数コードで環境変数を設定することも、関数のグループ固有設定に追加することもできます。構成設定として環境変数を追加する例については、この[ステップ](ml-console.md#ml-console-config-lambda)を参照してください。
**注記**
サードパーティのコード例を実行するなどの MXNet フレームワークの一般使用に対しては、環境変数を Raspberry Pi で設定する必要があります。
### Raspberry Pi での TensorFlow モデルの制限
推論結果を向上させるための推奨事項は、Raspberry Pi プラットフォームで TensorFlow 32-bit Arm ライブラリを使用したテストに基づいています。これらの推奨事項は、上級ユーザーのみを対象としており、いかなる種類の保証もありません。
+ [チェックポイント](https://www.tensorflow.org/guide/checkpoint)形式を使用してトレーニングされたモデルは、提供する前にプロトコルバッファ形式で "圧縮" する必要があります。例については、「[TensorFlow-Slim イメージ分類モデルライブラリ](https://github.com/tensorflow/models/tree/master/research/slim)」を参照してください。
+ TF-Estimator および TF-Slim ライブラリはトレーニングコードまたは推論コードで使用しないでください。代わりに、以下の例に示している `.pb` ファイルモデルロードパターンを使用してください。
```
graph = tf.Graph()
graph_def = tf.GraphDef()
graph_def.ParseFromString(pb_file.read())
with graph.as_default():
tf.import_graph_def(graph_def)
```
**注記**
TensorFlow でサポートされているプラットフォームの詳細については、TensorFlow のドキュメントの「[TensorFlow のインストール](https://www.tensorflow.org/install/#installing_from_sources)」を参照してください。
# Lambda 関数から機械学習リソースにアクセスする
ユーザー定義の Lambda 関数は、機械学習リソースにアクセスして、 AWS IoT Greengrass コアでローカル推論を実行できます。機械学習リソースは、トレーニングを受けたモデルと、コアデバイスにダウンロードされるその他のアーティファクトで構成されます。
Lambda 関数がコアの機械学習リソースにアクセスできるようにするには、リソースを Lambda 関数にアタッチし、アクセス権限を定義する必要があります。その際の手順は、関連付けられた (またはアタッチされた) Lambda 関数の[コンテナ化モード](lambda-group-config.md#lambda-function-containerization)によって決まります。
## 機械学習リソースのアクセス権限
AWS IoT Greengrass Core v1.10.0 以降では、機械学習リソースのリソース所有者を定義できます。リソース所有者は、 がリソースアーティファクトのダウンロード AWS IoT Greengrass に使用する OS グループとアクセス許可を表します。リソース所有者が定義されていない場合、ダウンロードされたリソースアーティファクトはルートにのみアクセスできます。
+ コンテナ化されていない Lambda 関数が機械学習リソースにアクセスする場合、コンテナからのアクセス権限制御がないため、リソースの所有者を定義する必要があります。コンテナ化されていない Lambda 関数は、リソース所有者のアクセス権限を継承し、それらを使用してリソースにアクセスできます。
+ コンテナ化された Lambda 関数だけがリソースにアクセスする場合は、リソース所有者を定義するのではなく、関数レベルのアクセス権限を使用することをお勧めします。
### リソース所有者のプロパティ
リソース所有者は、グループ所有者とグループ所有者の権限を指定します。
**グループの所有者**。コアデバイス上の既存の Linux OS グループのグループ ID (GID)。グループの権限が Lambda プロセスに追加されます。具体的には、Lambda 関数の補足グループ ID に GID が追加されます。
Greengrass グループの Lambda 関数が、機械学習リソースのリソース所有者と同じ OS グループ[として実行](lambda-group-config.md#lambda-access-identity)されるように設定されている場合は、そのリソースを Lambda 関数にアタッチする必要があります。それ以外の場合、この設定により Lambda 関数が AWS IoT Greengrass 認可なしでリソースにアクセスするために使用できる暗黙的なアクセス許可が付与されるため、デプロイは失敗します。Lambda 関数がルート (UID=0) として実行されている場合、デプロイ検証チェックはスキップされます。
Greengrass Core の他のリソース、Lambda 関数、ファイルで使用されていない OS グループを使用することをお勧めします。共有 OS グループを使用すると、アタッチされた Lambda 関数が必要以上に多くのアクセス権限を付与できます。共有 OS グループを使用する場合は、アタッチされた Lambda 関数も、その共有 OS グループを使用するすべての機械学習リソースにアタッチする必要があります。それ以外の場合、デプロイは失敗します。
**グループ所有者の権限**。Lambda プロセスに追加する読み取り専用権限、または読み取り/書き込み権限。
コンテナ化されていない Lambda 関数は、リソースに対するこれらのアクセス権限を継承する必要があります。コンテナ化された Lambda 関数は、これらのリソースレベルのアクセス権限を継承するか、関数レベルのアクセス権限を定義できます。関数レベルのアクセス権限を定義する場合、アクセス権限はリソースレベルのアクセス権限と同じか、制限がより大きいものである必要があります。
次のテーブルに、サポートされているアクセス権限の設定を示します。
------
#### [ GGC v1.10 or later ]
| プロパティ | コンテナ化された Lambda 関数のみがリソースにアクセスする場合 | コンテナ化されていない Lambda 関数がリソースにアクセスする場合 |
| --- |--- |--- |
| **関数レベルのプロパティ** |
| --- |
| 権限 (読み取り/書き込み) | リソースがリソース所有者を定義していない場合は必須です。リソース所有者が定義されている場合、関数レベルのアクセス権限は、リソース所有者のアクセス権限と同じか、制限がより大きいものである必要があります。 コンテナ化された Lambda 関数だけがリソースにアクセスする場合は、リソースの所有者を定義しないことをお勧めします。 | **コンテナ化されていない Lambda 関数:** サポート外。コンテナ化されていない Lambda 関数は、リソースレベルのアクセス権限を継承する必要があります。 **コンテナ化された Lambda 関数:** オプション。ただし、リソースレベルのアクセス権限と同じか制限がより大きいものである必要があります。 |
| **リソースレベルのプロパティ** |
| --- |
| リソース所有者 | オプション (推奨しません)。 | 必須。 |
| 権限 (読み取り/書き込み) | オプション (推奨しません)。 | 必須。 |
------
#### [ GGC v1.9 or earlier ]
| プロパティ | コンテナ化された Lambda 関数のみがリソースにアクセスする場合 | コンテナ化されていない Lambda 関数がリソースにアクセスする場合 |
| --- |--- |--- |
| **関数レベルのプロパティ** |
| --- |
| 権限 (読み取り/書き込み) | 必須。 | サポート外。 |
| **リソースレベルのプロパティ** |
| --- |
| リソース所有者 | サポート外。 | サポート外。 |
| 権限 (読み取り/書き込み) | サポート外。 | サポート外。 |
------
**注記**
AWS IoT Greengrass API を使用して Lambda 関数とリソースを設定する場合、関数レベルの`ResourceId`プロパティも必要です。`ResourceId` プロパティは、機械学習リソースを Lambda 関数にアタッチします。
## Lambda 関数のアクセス権限の定義 (コンソール)
AWS IoT コンソールでは、機械学習リソースを設定するとき、または Lambda 関数にアタッチするときにアクセス許可を定義します。
**コンテナ化された Lambda 関数**
コンテナ化された Lambda 関数だけが機械学習リソースにアタッチされている場合:
+ 機械学習リソースのリソース所有者として **[No system group]** (システムグループなし) を選択します。これは、コンテナ化された Lambda 関数だけが機械学習リソースにアクセスする場合に推奨される設定です。そうしないと、アタッチされた Lambda 関数が必要以上に多くのアクセス権限を与える可能性があります。
**コンテナ化されていない Lambda 関数** (GGC v1.10 以降が必要)
コンテナ化されていない Lambda 関数が機械学習リソースにアタッチされている場合:
+ 機械学習リソースのリソース所有者として使用する **System group ID (GID)** (システムグループ ID (GID)) を指定します。**[Specify system group and permissions]** (システムグループと権限を指定) を選択し、GID を入力します。コアデバイスで `getent group` コマンドを使用して、システムグループ ID を検索できます。
+ **[System group permissions]** (システムグループの権限) には **[Read-only access]** (読み取り専用アクセス) または **[Read and write access]** (読み取り/書き込みアクセス)] を選択します。
## Lambda 関数 (API) のアクセス権限の定義
AWS IoT Greengrass API では、Lambda 関数の `ResourceAccessPolicy`プロパティまたはリソースの `OwnerSetting`プロパティで機械学習リソースへのアクセス許可を定義します。
**コンテナ化された Lambda 関数**
コンテナ化された Lambda 関数だけが機械学習リソースにアタッチされている場合:
+ コンテナ化された Lambda 関数の場合は、`ResourceAccessPolicies` プロパティの `Permission` プロパティにアクセス権限を定義します。例:
```
"Functions": [
{
"Id": "my-containerized-function",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:function-name:alias-or-version",
"FunctionConfiguration": {
"Environment": {
"ResourceAccessPolicies": [
{
"ResourceId": "my-resource-id",
"Permission": "ro-or-rw"
}
]
},
"MemorySize": 512,
"Pinned": true,
"Timeout": 5
}
}
]
```
+ 機械学習リソースの場合は、`OwnerSetting` プロパティを省略します。例:
```
"Resources": [
{
"Id": "my-resource-id",
"Name": "my-resource-name",
"ResourceDataContainer": {
"S3MachineLearningModelResourceData": {
"DestinationPath": "/local-destination-path",
"S3Uri": "s3://uri-to-resource-package"
}
}
}
]
```
これは、コンテナ化された Lambda 関数だけが機械学習リソースにアクセスする場合に推奨される設定です。そうしないと、アタッチされた Lambda 関数が必要以上に多くのアクセス権限を与える可能性があります。
**コンテナ化されていない Lambda 関数** (GGC v1.10 以降が必要)
コンテナ化されていない Lambda 関数が機械学習リソースにアタッチされている場合:
+ コンテナ化されていない Lambda 関数の場合は、`ResourceAccessPolicies` の `Permission` プロパティを省略します。この設定は必須で、関数がリソースレベルのアクセス権限を継承できるようにします。例:
```
"Functions": [
{
"Id": "my-non-containerized-function",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:function-name:alias-or-version",
"FunctionConfiguration": {
"Environment": {
"Execution": {
"IsolationMode": "NoContainer",
},
"ResourceAccessPolicies": [
{
"ResourceId": "my-resource-id"
}
]
},
"Pinned": true,
"Timeout": 5
}
}
]
```
+ 機械学習リソースにもアクセスするコンテナ化された Lambda 関数の場合は、`ResourceAccessPolicies` で `Permission` プロパティを省略するか、リソースレベルのアクセス権限と同じ、または制限のより厳しいアクセス権限を定義します。例:
```
"Functions": [
{
"Id": "my-containerized-function",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:function-name:alias-or-version",
"FunctionConfiguration": {
"Environment": {
"ResourceAccessPolicies": [
{
"ResourceId": "my-resource-id",
"Permission": "ro-or-rw" // Optional, but cannot exceed the GroupPermission defined for the resource.
}
]
},
"MemorySize": 512,
"Pinned": true,
"Timeout": 5
}
}
]
```
+ 機械学習リソースの場合は、子 `GroupOwner` および `GroupPermission` プロパティを含む `OwnerSetting` プロパティを定義します。例:
```
"Resources": [
{
"Id": "my-resource-id",
"Name": "my-resource-name",
"ResourceDataContainer": {
"S3MachineLearningModelResourceData": {
"DestinationPath": "/local-destination-path",
"S3Uri": "s3://uri-to-resource-package",
"OwnerSetting": {
"GroupOwner": "os-group-id",
"GroupPermission": "ro-or-rw"
}
}
}
}
]
```
## Lambda 関数コードから機械学習リソースにアクセスする
ユーザー定義の Lambda 関数は、プラットフォーム固有の OS インターフェイスを使用して、Core デバイスの機械学習リソースにアクセスします。
------
#### [ GGC v1.10 or later ]
コンテナ化された Lambda 関数の場合、リソースは Greengrass コンテナ内にマウントされ、リソースに対して定義されたローカルの送信先パスで利用できます。コンテナ化されていない Lambda 関数の場合、リソースは Lambda 専用の作業ディレクトリにシンボリックリンクされ、Lambda プロセス内の `AWS_GG_RESOURCE_PREFIX` 環境変数に渡されます。
機械学習リソースのダウンロードされたアーティファクトへのパスを取得するために、Lambda 関数は、リソースに対して定義されたローカルの送信先パスに `AWS_GG_RESOURCE_PREFIX` 環境変数を追加します。コンテナ化された Lambda 関数の場合、返される値は 1 つのスラッシュ (`/`) です。
```
resourcePath = os.getenv("AWS_GG_RESOURCE_PREFIX") + "/destination-path"
with open(resourcePath, 'r') as f:
# load_model(f)
```
------
#### [ GGC v1.9 or earlier ]
機械学習リソースのダウンロードされたアーティファクトは、リソースに対して定義されたローカルの送信先パスにあります。 AWS IoT Greengrass Core v1.9 以前の機械学習リソースにアクセスできるのは、コンテナ化された Lambda 関数だけです。
```
resourcePath = "/local-destination-path"
with open(resourcePath, 'r') as f:
# load_model(f)
```
------
モデルのロード実装は、ML ライブラリによって異なります。
## トラブルシューティング
次の情報を使用して、機械学習リソースへのアクセスに関する問題のトラブルシューティングに役立ててください。
**Topics**
+ [InvalidMLModelOwner - GroupOwnerSetting は ML モデルリソースに提供されていますが、GroupOwner または GroupPermission がありません](#nocontainer-lambda-invalid-ml-model-owner)
+ [NoContainer 関数は、機械学習リソースをアタッチするときにアクセス権限を設定できません。 は、リソースアクセスポリシーでアクセス権限 を持つ機械学習リソース を参照します。](#nocontainer-lambda-invalid-resource-access-policy)
+ [関数 は機械学習リソース を参照しますが、ResourceAccessPolicy とリソースの OwnerSetting のどちらにもアクセス権限がありません。](#nocontainer-lambda-missing-access-permission)
+ [関数 は \$1"rw\$1" アクセス権限で機械学習リソース を参照しますが、リソース所有者設定の GroupPermission で許可されているのは \$1"ro\$1" のみです。](#container-lambda-invalid-rw-permissions)
+ [NoContainer 関数 は、ネストされた送信先パスのリソースを参照します。](#nocontainer-lambda-nested-destination-path)
+ [Lambda は、同じグループ所有者 ID を共有することでリソース にアクセスします。](#lambda-runas-and-resource-owner)
### InvalidMLModelOwner - GroupOwnerSetting は ML モデルリソースに提供されていますが、GroupOwner または GroupPermission がありません
**解決策:** このエラーは、機械学習リソースに [ResourceDownloadOwnerSetting](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resourcedownloadownersetting.html) オブジェクトが含まれていても、必須の `GroupOwner` または `GroupPermission` プロパティが定義されていない場合に表示されます。この問題を解決するには、不足しているプロパティを定義します。
### NoContainer 関数は、機械学習リソースをアタッチするときにアクセス権限を設定できません。 は、リソースアクセスポリシーでアクセス権限 を持つ機械学習リソース を参照します。
**解決策:** コンテナ化されていない Lambda 関数が機械学習リソースに対する関数レベルのアクセス権限を指定した場合、このエラーが表示されます。コンテナ化されていない関数は、機械学習リソースに定義されているリソース所有者のアクセス権限からアクセス権限を継承する必要があります。この問題を解決するには、コンソールから [[inherit resource owner permissions]](#non-container-config-console) (リソース所有者のアクセス許可を継承する) を選択するか、API を使用して [Lambda 関数のリソースアクセスポリシーからアクセス権限を削除する](#non-container-config-api)かを選択します。
### 関数 は機械学習リソース を参照しますが、ResourceAccessPolicy とリソースの OwnerSetting のどちらにもアクセス権限がありません。
**解決策:** このエラーは、機械学習リソースへのアクセス権限が、アタッチされた Lambda 関数またはリソースに対して設定されていない場合に表示されます。この問題を解決するには、Lambda 関数の [ResourceAccessPolicy](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resourceaccesspolicy.html) プロパティか、またはリソースの [OwnerSetting](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-ownersetting.html) プロパティにアクセス権限を設定します。
### 関数 は \$1"rw\$1" アクセス権限で機械学習リソース を参照しますが、リソース所有者設定の GroupPermission で許可されているのは \$1"ro\$1" のみです。
**解決策:** このエラーは、アタッチされた Lambda 関数に定義されたアクセス権限が、機械学習リソースに対して定義されたリソース所有者のアクセス権限を超えた場合に表示されます。この問題を解決するには、Lambda 関数に対して制限のより厳しいアクセス権限を設定するか、リソース所有者の制限がより低いアクセス権限を設定します。
### NoContainer 関数 は、ネストされた送信先パスのリソースを参照します。
**解決策:** コンテナ化されていない Lambda 関数にアタッチされた複数の機械学習リソースが同じ送信先パスまたはネストされた送信先パスを使用している場合に、このエラーが表示されます。この問題を解決するには、リソースに別の送信先パスを指定します。
### Lambda は、同じグループ所有者 ID を共有することでリソース にアクセスします。
**解決策:** このエラーは、Lambda 関数の[実行者](lambda-group-config.md#lambda-access-identity) ID と、機械学習リソースの[リソース所有者](#ml-resource-owner)に同じ OS グループを指定しながら、リソースが Lambda 関数にアタッチされていない場合に `runtime.log` に記録されます。この設定では、Lambda 関数に暗黙のアクセス権限が付与されます。このアクセス権限は、 AWS IoT Greengrass の認可なしでリソースにアクセスするために使用できます。
この問題を解決するには、プロパティの 1 つに別の OS グループを使用するか、機械学習リソースを Lambda 関数にアタッチします。
## 関連情報
+ [機械学習の推論を実行する](ml-inference.md)
+ [を使用して機械学習推論を設定する方法 AWS マネジメントコンソール](ml-console.md)
+ [を使用して最適化された機械学習推論を設定する方法 AWS マネジメントコンソール](ml-dlc-console.md)
+ [AWS IoT Greengrass Version 1 API リファレンス](https://docs.aws.amazon.com/greengrass/v1/apireference/api-doc.html)
# を使用して機械学習推論を設定する方法 AWS マネジメントコンソール
このチュートリアルのステップに従うには、 AWS IoT Greengrass Core v1.10 以降が必要です。
ローカルに生成されたデータを使用して、Greengrass コアデバイスで機械学習 (ML) 推論をローカルで実行できます。要件と制約を含め、情報については、「[機械学習の推論を実行する](ml-inference.md)」を参照してください。
このチュートリアルでは、 を使用して Greengrass グループを設定し、クラウド AWS マネジメントコンソール にデータを送信せずにカメラからのイメージをローカルで認識する Lambda 推論アプリケーションを実行する方法について説明します。推論アプリケーションは、Raspberry Pi 上のカメラモジュールにアクセスし、オープンソースの [SqueezeNet](https://github.com/DeepScale/SqueezeNet) モデルを使用して推論を実行します。
このチュートリアルのおおまかな手順は以下のとおりです。
1. [Raspberry Pi を設定する](#config-raspberry-pi)
1. [MXNet フレームワークをインストールする](#install-mxnet)
1. [モデルパッケージを作成する](#package-ml-model)
1. [Lambda 関数を作成して発行する](#ml-console-create-lambda)
1. [グループに Lambda 関数を追加する](#ml-console-config-lambda)
1. [グループにリソースを追加する](#ml-console-add-resources)
1. [グループにサブスクリプションを追加する](#ml-console-add-subscription)
1. [グループをデプロイする](#ml-console-deploy-group)
1. [アプリケーションをテストする](#ml-console-test-app)
## 前提条件
このチュートリアルを完了するには、以下が必要です。
+ Raspberry Pi 4 モデル B、または Raspberry Pi 3 モデル B/B\$1 は、 で使用するようにセットアップおよび設定されています AWS IoT Greengrass。Raspberry Pi を AWS IoT Greengrassと共にセットアップする前に、[Greengrass Device Setup](quick-start.md) スクリプトを実行するか、[の開始方法 AWS IoT Greengrass](gg-gs.md) の[モジュール 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) と[モジュール 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) を完了していることを確認します。
**注記**
Raspberry Pi では、イメージ分類に一般的に使用される深層学習のフレームワークを動かすために、2.5A の[電源](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/)が必要な場合があります。定格の低い電源を使用すると、デバイスが再起動する場合があります。
+ [Raspberry Pi カメラモジュール V2 - 8 メガピクセル、1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS)。カメラの設定方法については、Raspberry Pi ドキュメントの[カメラの接続](https://www.raspberrypi.org/documentation/usage/camera/)に関するトピックを参照してください。
+ Greengrass グループと Greengrass コア。Greengrass グループまたはコアを作成する方法については、「[の開始方法 AWS IoT Greengrass](gg-gs.md)」を参照してください。
**注記**
このチュートリアルでは Raspberry Pi を使用しますが、[Intel Atom](#atom-lambda-config) や [NVIDIA Jetson TX2 ](#jetson-lambda-config)などの他のプラットフォーム AWS IoT Greengrass をサポートしています。Jetson TX2 の例は、カメラからストリームされた画像の代わりに静的画像を使用できます。Jetson TX2 の例を使用する場合は、Python 3.7 ではなく Python 3.6 をインストールする必要があります。 AWS IoT Greengrass Core ソフトウェアをインストールできるようにデバイスを設定する方法については、「」を参照してください[他のデバイスの設定](setup-filter.other.md)。
AWS IoT Greengrass がサポートしていないサードパーティープラットフォームの場合は、Lambda 関数をコンテナ化されていないモードで実行する必要があります。非コンテナ化モードで実行するには、Lambda 関数を root として実行する必要があります。詳細については、「[Lambda 関数のコンテナ化を選択する場合の考慮事項](lambda-group-config.md#lambda-containerization-considerations)」および「[グループ内の Lambda 関数に対するデフォルトのアクセス ID の設定](lambda-group-config.md#lambda-access-identity-groupsettings)」を参照してください。
## ステップ 1: Raspberry Pi を設定する
このステップでは、Raspbian オペレーティングシステムの更新プログラムをインストールし、カメラモジュールソフトウェアと Python の依存関係をインストールして、カメラインターフェイスを有効にします。
Raspberry Pi のターミナルで以下のコマンドを実行します。
1. Raspbian に更新プログラムをインストールします。
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. カメラモジュールの `picamera` インターフェイス、およびこのチュートリアルに必要なその他の Python ライブラリをインストールします。
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
インストールを検証します。
+ Python 3.7 のインストールに pip が含まれていることを確認します。
```
python3 -m pip
```
pip がインストールされていない場合は、[pip ウェブサイト](https://pip.pypa.io/en/stable/installing/)からダウンロードし、次のコマンドを実行します。
```
python3 get-pip.py
```
+ Python のバージョンが 3.7 以上であることを確認します。
```
python3 --version
```
出力に以前のバージョンが表示されている場合は、次のコマンドを実行します。
```
sudo apt-get install -y python3.7-dev
```
+ Setuptools と Picamera が正常にインストールされたことを確認します。
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
出力にエラーが含まれていない場合、検証は成功です。
**注記**
デバイスにインストールされている Python 実行可能ファイルが `python3.7` である場合は、このチュートリアルのコマンドに `python3` ではなく、`python3.7` を使用します。依存関係のエラーを回避するために、pip インストールが正しい `python3` バージョンまたは `python3.7` バージョンにマップされていることを確認してください。
1. Raspberry Pi を再起動します。
```
sudo reboot
```
1. Raspberry Pi 設定ツールを開きます。
```
sudo raspi-config
```
1. 矢印キーを使用して **[インターフェイスオプション]** を開き、カメラインターフェイスを有効にします。プロンプトが表示されたら、デバイスを再起動します。
1. 以下のコマンドを使用して、カメラの設定をテストします。
```
raspistill -v -o test.jpg
```
これにより、Raspberry Pi のプレビューウィンドウが開き、`test.jpg` という写真が現在のディレクトリに保存されて、カメラに関する情報が Raspberry Pi のターミナルに表示されます。
## ステップ 2: MXNet フレームワークをインストールする
このステップでは、Raspberry Pi に MXNet ライブラリをインストールします。
1. リモートで Raspberry Pi にサインインします。
```
ssh pi@your-device-ip-address
```
1. MXNet のドキュメントを開き、[MXNet のインストール](https://mxnet.apache.org/get_started/?)を開いて、指示に従って MXNet をデバイスにインストールします。
**注記**
このチュートリアルでは、デバイスの競合を回避するために、バージョン 1.5.0 をインストールし、ソースから MXNet をビルドすることをお勧めします。
1. MXNet をインストールしたら、次の設定を検証します。
+ `ggc_user` システムアカウントが MXNet フレームワークを使用できることを確認します。
```
sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
+ NumPy がインストールされていることを確認します。
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## ステップ 3: MXNet モデルパッケージを作成する
このステップでは、Amazon Simple Storage Service (Amazon S3) にアップロードする事前トレーニング済みのサンプル MXNet モデルを含むモデルパッケージを作成します。tar.gz または zip 形式を使用する場合、 AWS IoT Greengrass は Amazon S3 のモデルパッケージを使用できます。Amazon S3
1. コンピュータで、[機械学習のサンプル](what-is-gg.md#gg-ml-samples) から Raspberry Pi 用の MXNet サンプルをダウンロードします。
1. ダウンロードした `mxnet-py3-armv7l.tar.gz` ファイルを解凍します。
1. `squeezenet` ディレクトリに移動します。
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/models/squeezenet
```
このディレクトリ内の `squeezenet.zip` ファイルはモデルパッケージです。これには、イメージ分類モデルの SqueezeNet オープンソースモデルアーティファクトが含まれています。後で、このモデルパッケージを Amazon S3 にアップロードします。
## ステップ 4: Lambda 関数を作成して発行する
この手順では、Lambda 関数デプロイパッケージと Lambda 関数を作成します。次に、関数のバージョンを公開し、エイリアスを作成します。
まず、Lambda 関数デプロイパッケージを作成します。
1. コンピュータで、「[ステップ 3: MXNet モデルパッケージを作成する](#package-ml-model)」で解凍したサンプルパッケージ内の `examples` ディレクトリに移動します。
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/examples
```
`examples` ディレクトリには、関数コードと依存関係が含まれています。
+ `greengrassObjectClassification.py` は、このチュートリアルで使用される推論コードです。このコードをテンプレートとして使用して、独自の推論関数を作成できます。
+ `greengrasssdk` は、 AWS IoT Greengrass Core SDK for Python のバージョン 1.5.0 です。
**注記**
新しいバージョンが利用できる場合は、そのバージョンをダウンロードし、デプロイパッケージ内の SDK バージョンをアップグレードできます。詳細については、GitHub の「[AWS IoT Greengrass Core SDK for Python](https://github.com/aws/aws-greengrass-core-sdk-python/)」を参照してください。
1. `examples` ディレクトリの内容を `greengrassObjectClassification.zip` という名前のファイルに圧縮します。このファイルがデプロイパッケージです。
```
zip -r greengrassObjectClassification.zip .
```
**注記**
`.py` ファイルと依存関係がディレクトリのルートにあることを確認します。
次に、Lambda 関数を作成します。
1. AWS IoT コンソールから、**関数** と **関数の作成** を選択します。
1. **[一から作成]** を選択し、以下の値を使用して関数を作成します。
+ **[関数名]** に「**greengrassObjectClassification**」と入力します。
+ **[ランタイム]** で **[Python 3.7]** を選択します。
**[アクセス許可]** はデフォルト設定のままにしておきます。これで Lambda への基本的なアクセス許可を付与する実行ロールが作成されます。このロールは では使用されません AWS IoT Greengrass。
1. [**関数の作成**] を選択してください。
今度は、Lambda 関数デプロイパッケージをアップロードし、ハンドラを登録します。
1. [Lambda function](Lambda 関数) を選択し、Lambda 関数のデプロイパッケージをアップロードします。
1. **[コード]** タブの **[コードソース]** で、**[アップロード元]** を選択します。ドロップダウンから **[.zip ファイル]** を選択します。
![\[[.zip ファイル] が強調表示された [アップロード元] ドロップダウンリスト。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. **[アップロード]** を選択し、`greengrassObjectClassification.zip` デプロイパッケージを選択します。次に、**[保存]** を選択します。
1. 関数の **[Code]** (コード) タブにある **[Runtime settings]** (ランタイム設定) で **[Edit]** (編集) を選択し、次の値を入力します。
+ **[ランタイム]** で **[Python 3.7]** を選択します。
+ **[ハンドラ]** に **greengrassObjectClassification.function\$1handler** と入力します。
**[保存]** を選択します。
次に、Lambda 関数の最初のバージョンを発行します。その後、[バージョンのエイリアス](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html)を作成します。
**注記**
Greengrass グループは、Lambda 関数をエイリアス別 (推奨) またはバージョン別に参照できます。エイリアスを使用すると、関数コードを更新する時にサブスクリプションテーブルやグループ定義を変更する必要がないため、コード更新を簡単に管理できます。その代わりに、新しい関数バージョンにエイリアスを指定するだけで済みます。
1. **[アクション]** メニューから、**[新しいバージョンを発行]** を選択します。
![\[[アクション] メニューの [新しいバージョンを発行] オプション。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/ml-inference/lambda-publish-version.png)
1. **[バージョンの説明]** に **First version** と入力し、**[発行]** を選択します。
1. [**greengrassObjectClassification: 1**] 設定ページで、[**Actions**] (アクション) メニューの [**エイリアスの作成**] を選択します。
![\[[アクション] メニューの [エイリアスの作成] オプション。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/ml-inference/lambda-create-alias.png)
1. **[新しいエイリアスの作成]** ページで、次の値を使用します。
+ [**名前**] に**mlTest**と入力してください。
+ **[バージョン]** に **1** と入力します。
**注記**
AWS IoT Greengrass は、**\$1LATEST** バージョンの Lambda エイリアスをサポートしていません。
1. **[保存]** を選択します。
次に、Lambda 関数を Greengrass グループに追加します。
## ステップ 5: Lambda 関数を Greengrass グループに追加する
このステップでは、Lambda 関数をグループに追加してから、そのライフサイクルと環境変数を設定します。
まず、Lambda 関数を Greengrass グループに追加します。
1. AWS IoT コンソールナビゲーションペインの**「管理**」で **Greengrass デバイス**を展開し、**「グループ (V1)**」を選択します。
1. グループ設定ページで、**[Lambda functions]** (Lambda 関数) タブを選択します。
1. **[My Lambda functions]** (自分の Lambda 関数) セクションから、**[Add]**（追加）を選択します。
1. **[Lambda 関数]** で、**[greengrassObjectClassification]** を選択します。
1. **Lambda 関数のバージョン**で、**Alias:mlTest** を選択します。
次に、Lambda 関数のライフサイクルと環境変数を設定します。
1. **[Lambda function configuration]** (Lambda 関数の設定) セクションで次のように更新します。
**注記**
ビジネスケースで要求される場合を除き、Lambda 関数はコンテナ化を使用せずに実行することをお勧めします。これにより、デバイスリソースを設定しなくても、デバイスの GPU とカメラにアクセスできるようになります。コンテナ化なしで を実行する場合は、 AWS IoT Greengrass Lambda 関数へのルートアクセスも許可する必要があります。
1. **コンテナ化を使用せずに実行するには:**
+ **[System user and group]** (システムユーザーとグループ) で、**Another user ID/group ID**を選択します。**[System user ID]** (システムユーザ ID) には、「**0**」と入力します。**[System group ID]** (システムグループ ID) には、「**0**」と入力します。
これにより、Lambda 関数を root として実行できます。root として実行の詳細については、「[グループ内の Lambda 関数に対するデフォルトのアクセス ID の設定](lambda-group-config.md#lambda-access-identity-groupsettings)」を参照してください。
**ヒント**
また、ルートアクセスを Lambda 関数に付与するように `config.json` ファイルを更新する必要があります。手順については、「[root としての Lambda 関数の実行](lambda-group-config.md#lambda-running-as-root)」を参照してください。
+ **[Lambda function containerization]** (Lambda 関数のコンテナ化) で、**[No container]** (コンテナなし) を選択します。
コンテナ化を使用しない実行の詳細については、「[Lambda 関数のコンテナ化を選択する場合の考慮事項](lambda-group-config.md#lambda-containerization-considerations)」を参照してください。
+ **[タイムアウト]** に **10 seconds** と入力します。
+ **[固定]** で、**[True]** を選択します。
詳細については、「[Greengrass Lambda 関数のライフサイクル設定](lambda-functions.md#lambda-lifecycle)」を参照してください。
1. **代わりにコンテナ化モードで実行するには:**
**注記**
ビジネスケースで要求されない限り、コンテナ化モードでの実行はお勧めしていません。
+ **[System user and group]** (システムユーザーとグループ) で、**[Use group default]** (グループのデフォルトを使用) を選択します。
+ **[Lambda function containerization]** (Lambda 関数のコンテナ化) で、**[Use group default]** (グループのデフォルトを使用) を選択します。
+ **[メモリ制限]** に **96 MB** と入力します。
+ **[タイムアウト]** に **10 seconds** と入力します。
+ **[固定]** で、**[True]** を選択します。
詳細については、「[Greengrass Lambda 関数のライフサイクル設定](lambda-functions.md#lambda-lifecycle)」を参照してください。
1. **[環境変数]** で、キーと値のペアを作成します。キーと値のペアは、Raspberry Pi 上で MXNet モデルとやり取りする関数で必要となります。
キーには、MXNET\$1ENGINE\$1TYPE を使用します。値には、NaiveEngine を使用します。
**注記**
独自のユーザー定義 Lambda 関数では、必要に応じて、関数コードで環境変数を設定できます。
1. 他のすべてのプロパティではデフォルト値を保持し、**[Add Lambda function]** (Lambda 関数の追加) を選択します。
## ステップ 6: Greengrass グループにリソースを追加する
このステップでは、カメラモジュールと ML 推論モデルのリソースを作成し、リソースを Lambda 関数に関連付けます。これにより、Lambda 関数がコアデバイス上のリソースにアクセスできるようになります。
**注記**
コンテナ化されていないモードで を実行すると、 AWS IoT Greengrass はこれらのデバイスリソースを設定せずにデバイス GPU とカメラにアクセスできます。
まず、カメラ用に 2 つのローカルデバイスリソースを作成します。1 つは共有メモリ用、もう 1 つはデバイスインターフェイス用です。ローカルリソースアクセスの詳細については、「[Lambda 関数とコネクタを使用してローカルリソースにアクセスする](access-local-resources.md)」を参照してください。
1. グループ設定ページで、**[Resources]** (リソース) タブを選択します。
1. **[Local resources]** (ローカルリソース) タブで、**[Add local resource]** (ローカルリソースの追加) を選択します。
1. **[Add a local resource]** (ローカルリソースの追加) ページで、次の値を使用します。
+ **[リソース名]** に **videoCoreSharedMemory** と入力します。
+ **[リソースタイプ]** で、**[デバイス]** を選択します。
+ **[Local device path]** (ローカルデバイスパス) には、「**/dev/vcsm**」と入力します。
デバイスパスはデバイスリソースのローカル絶対パスです。このパスでは、`/dev` 以下のキャラクターデバイスまたはブロックデバイスのみを参照できます。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
**[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス権限) オプションを使用すると、Lambda プロセスに追加のファイルアクセス権限をグラントできます。詳細については、「[グループ所有者のファイルアクセス権限](access-local-resources.md#lra-group-owner)」を参照してください。
1. 次に、カメラインターフェイス用にローカルデバイスリソースを追加します。
1. **[Add local resource]** (ローカルリソースの追加) を選択します。
1. **[Add a local resource]** (ローカルリソースの追加) ページで、次の値を使用します。
+ **[リソース名]** に **videoCoreInterface** と入力します。
+ **[リソースタイプ]** で、**[デバイス]** を選択します。
+ **[Local device path]** (ローカルデバイスパス) には、「**/dev/vchiq**」と入力します。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
1. ページの下部で、[**Add resource**] (リソースの追加) を選択します。
ここで、推論モデルを機械学習リソースとして追加します。このステップでは、`squeezenet.zip` モデルパッケージを Amazon S3 にアップロードします。
1. グループの **[Resources]** (リソース) タブの、**[Machine Learning]** (機械学習) で、**[Add machine learning resour]** (機械学習リソースの追加) を選択します。
1. **[Add a machine learning resource (機械学習リソースの追加)** ページで、**[Resource name]** (リソース名) に、「 **squeezenet\$1model**」と入力します。
1. **[Model source]** (モデルソース) で、**[Use a model stored in S3, such as a model optimized through Deep Learning Compiler]** (深層学習コンパイラで最適化されたモデルなど、S3 に保存されているモデルを使用する) を選択します。
1. **[S3 URI]**には、S3 バケットが保存されているパスを入力します。
1. **[S3 を参照]** を選択します。これにより、新しいタブで Amazon S3 コンソールが開きます。
1. Amazon S3 コンソールタブで、`squeezenet.zip` ファイルを S3 バケットにアップロードします。詳細については、「Amazon Simple Storage Service ユーザーガイド」の「[S3 バケットにファイルとフォルダをアップロードする方法](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html)」を参照してください。
**注記**
S3 バケットにアクセスできるようにするには、バケット名に文字列 **greengrass** が含まれている必要があります。バケットは、 AWS IoT Greengrassに使用するリージョンと同じリージョンに存在する必要があります。一意の名前 (**greengrass-bucket-*user-id*-*epoch-time*** など) を選択します。バケット名にピリオド (`.`) を使用しないでください。
1. AWS IoT Greengrass コンソールタブで、S3 バケットを見つけて選択します。アップロードした `squeezenet.zip` ファイルを見つけ、**[選択]** を選択します。利用可能なバケットとファイルのリストを更新するために [**更新**] を選択する必要がある場合があります。
1. **[送信先パス]** に **/greengrass-machine-learning/mxnet/squeezenet** と入力します。
これは、Lambda ランタイム名前空間内のローカルモデルのターゲットです。グループをデプロイすると、 はソースモデルパッケージ AWS IoT Greengrass を取得し、指定したディレクトリにコンテンツを抽出します。このチュートリアルのサンプル Lambda 関数は、このパス (`model_path` 変数) を使用するように既に設定されています。
1. **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可) で、**[No system group]** (システムグループなし) を選択します。
1. **[リソースを追加]** を選択します。
### SageMaker AI トレーニング済みモデルの使用
このチュートリアルでは、Amazon S3 に保存されているモデルを使用しますが、SageMaker AI モデルも簡単に使用できます。 AWS IoT Greengrass コンソールには SageMaker AI 統合が組み込まれているため、これらのモデルを Amazon S3 に手動でアップロードする必要はありません。SageMaker AI モデルを使用する際の要件と制限については、「」を参照してください[サポートされているモデルソース](ml-inference.md#supported-model-sources)。
SageMaker AI モデルを使用するには:
+ **モデルソース**で、**SageMaker AI で AWS トレーニングされたモデルを使用し**、モデルのトレーニングジョブの名前を選択します。
+ **[Destination path]** (送信先) に、Lambda 関数によってモデルが検索されるディレクトリへのパスを入力します。
## ステップ 7: Greengrass グループにサブスクリプションを追加する
このステップでは、グループにサブスクリプションを追加します。このサブスクリプションにより、Lambda 関数は MQTT トピックに発行 AWS IoT することで、予測結果を に送信できます。
1. グループ設定ページで、**[Subscriptions]** (サブスクリプション) タブ、**[Add Subscription]** (サブスクリプションの追加) の順に選択します。
1. **[Subscription details]** (サブスクリプションの詳細) ページで、ソースおよびターゲットを次のように設定します。
1. **[Source type]** (ソースタイプ) で、**[Lambda function]** (Lambda 関数)、**[greengrassObjectClassification]** の順に選択します。
1. **[Target type]** (ターゲットタイプ)で、**[Service]** (サービス)、**[IoT Cloud]** (IoT クラウド) の順に選択します。
1. **[Topic filter]** (トピックのフィルター) で、「**hello/world**」と入力し、**[Create subscription]** (サブスクリプションの作成) を選択します。
## ステップ 8: Greengrass グループをデプロイする
このステップでは、グループ定義の現在のバージョンを Greengrass コアデバイスにデプロイします。この定義には、追加した Lambda 関数、リソース、サブスクリプション設定が含まれます。
1. AWS IoT Greengrass コアが実行されていることを確認します。必要に応じて、Raspberry Pi のターミナルで以下のコマンドを実行します。
1. デーモンが実行中かどうかを確認するには、以下を実行します。
```
ps aux | grep -E 'greengrass.*daemon'
```
出力に `root` で実行中の `/greengrass/ggc/packages/1.11.6/bin/daemon` のエントリが含まれていれば、デーモンは実行されています。
**注記**
パスのバージョンは、コアデバイスにインストールされている AWS IoT Greengrass Core ソフトウェアのバージョンによって異なります。
1. デーモンを開始するには、以下を実行します。
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. グループ設定ページで、**[Deploy]** (デプロイ) を選択します。
![\[[デプロイ] と [デプロイ] が強調表示されたグループの設定ページ。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/console-group-deployments-deploy.png)
1. **[Lambda functions]** (Lambda 関数) タブの **[System Lambda functions]** (システム Lambda 関数) セクションで、**[IP detector]** (IP ディテクター)、**[Edit\$1** (編集) の順に選択します。
1. **[IP ディテクターの設定を編集]** ダイアログボックスで、**[MQTT ブローカーエンドポイントを自動的に検出して上書きする]** を選択します。
1. **[保存]** を選択します。
これにより、デバイスは、IP アドレス、DNS、ポート番号など、コアの接続情報を自動的に取得できます。自動検出が推奨されますが、手動で指定されたエンドポイント AWS IoT Greengrass もサポートされます。グループが初めてデプロイされたときにのみ、検出方法の確認が求められます。
**注記**
プロンプトが表示されたら、[Greengrass サービスロール](service-role.md)を作成し、それを現在の AWS アカウント の に関連付けるアクセス許可を付与します AWS リージョン。このロールにより AWS IoT Greengrass 、 は AWS サービスのリソースにアクセスできます。
**[デプロイ]** ページには、デプロイのタイムスタンプ、バージョン ID、ステータスが表示されます。完了すると、デプロイのステータスが **[Completed]** (完了) と表示されます。
デプロイの詳細については、「[AWS IoT Greengrass コアに AWS IoT Greengrass グループをデプロイする](deployments.md)」を参照してください。トラブルシューティングのヘルプについては、「[トラブルシューティング AWS IoT Greengrass](gg-troubleshooting.md)」を参照してください。
## ステップ 9: 推論アプリケーションをテストする
これで、デプロイが正しく設定されているかどうかを確認できます。テストするには、`hello/world` トピックにサブスクライブし、Lambda 関数によって発行された予測結果を表示します。
**注記**
モニターが Raspberry Pi に接続されている場合、ライブカメラのフィードがプレビューウィンドウに表示されます。
1. AWS IoT コンソールの**テスト**で、**MQTT テストクライアント**を選択します。
1. **[サブスクリプション]** で、以下の値を使用します。
+ サブスクリプションのトピックには、hello/world を使用します。
+ **[Additional configuration]** (追加設定) から、**[MQTT payload display]** (MQTT ペイロード表示) で、**[Display payloads as strings]** (文字列としてペイロードを表示) を選択します。
1. **[サブスクライブ]** を選択します。
テストに成功すると、Lambda 関数からのメッセージがページの下部に表示されます。各メッセージには、確率、予測クラス ID、対応するクラス名の形式を使用して、イメージの上位 5 つの予測結果が含まれます。
![\[テスト結果とメッセージデータを示す [サブスクリプション] ページ。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/ml-inference/prediction-results.png)
### ML AWS IoT Greengrass 推論のトラブルシューティング
テストに成功しなかった場合は、以下のトラブルシューティング手順を実行できます。Raspberry Pi のターミナルで以下のコマンドを実行します。
#### エラーログを確認する
1. root ユーザーに切り替え、`log` ディレクトリに移動します。 AWS IoT Greengrass ログにアクセスするには、ルートアクセス許可が必要です。
```
sudo su
cd /greengrass/ggc/var/log
```
1. `system` ディレクトリで、`runtime.log` または `python_runtime.log` を確認します。
`user/region/account-id` ディレクトリで、`greengrassObjectClassification.log` を確認します。
詳細については、「[ログによるトラブルシューティング](gg-troubleshooting.md#troubleshooting-logs)」を参照してください。
##### runtime.log 内の 解凍エラー
`runtime.log` に以下のようなエラーが含まれる場合は、`tar.gz` ソースモデルパッケージに親ディレクトリがあることを確認します。
```
Greengrass deployment error: unable to download the artifact model-arn: Error while processing.
Error while unpacking the file from /tmp/greengrass/artifacts/model-arn/path to /greengrass/ggc/deployment/path/model-arn,
error: open /greengrass/ggc/deployment/path/model-arn/squeezenet/squeezenet_v1.1-0000.params: no such file or directory
```
モデルファイルを格納する親ディレクトリがパッケージに含まれていない場合は、以下のコマンドを使用してモデルを再パッケージ化します。
```
tar -zcvf model.tar.gz ./model
```
例:
```
─$ tar -zcvf test.tar.gz ./test
./test
./test/some.file
./test/some.file2
./test/some.file3
```
**注記**
このコマンドでは、末尾に `/*` 文字を含めないでください。
#### Lambda 関数が正常にデプロイされていることを確認する
1. `/lambda` ディレクトリ内のデプロイされた Lambda の内容を一覧表示します。コマンドを実行する前に、プレースホルダーの値を置き換えてください。
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. ディレクトリに、[ステップ 4: Lambda 関数を作成して発行する](#ml-console-create-lambda) でアップロードした `greengrassObjectClassification.zip` デプロイパッケージと同じ内容が含まれることを確認します。
`.py` ファイルと依存関係がディレクトリのルートにあることを確認します。
#### 推論モデルが正常にデプロイされていることを確認する
1. Lambda ランタイムプロセスのプロセス識別番号 (PID) を見つけます。
```
ps aux | grep 'lambda-function-name*'
```
出力では、Lambda ランタイムプロセスの行の 2 列目に PID が表示されます。
1. Lambda ランタイム名前空間を入力します。コマンドを実行する前に、*pid* プレースホルダーの値を置き換えてください。
**注記**
このディレクトリとその内容は、Lambda ランタイム名前空間にあるため、通常の Linux 名前空間には表示されません。
```
sudo nsenter -t pid -m /bin/bash
```
1. ML リソース用に指定したローカルディレクトリの内容を一覧表示します。
```
cd /greengrass-machine-learning/mxnet/squeezenet/
ls -ls
```
以下のファイルが表示されます。
```
32 -rw-r--r-- 1 ggc_user ggc_group 31675 Nov 18 15:19 synset.txt
32 -rw-r--r-- 1 ggc_user ggc_group 28707 Nov 18 15:19 squeezenet_v1.1-symbol.json
4832 -rw-r--r-- 1 ggc_user ggc_group 4945062 Nov 18 15:19 squeezenet_v1.1-0000.params
```
## 次の手順
次に、他の推論アプリを調べます。 は、ローカル推論を試すために使用できる他の Lambda 関数 AWS IoT Greengrass を提供します。サンプルパッケージは、「[ステップ 2: MXNet フレームワークをインストールする](#install-mxnet)」でダウンロードしたプリコンパイル済みライブラリフォルダにあります。
## インテル Atom の設定
Intel Atom デバイスでこのチュートリアルを実行するには、ソースイメージを指定し、Lambda 関数を設定して、別のローカルデバイスリソースを追加する必要があります。GPU を推論に使用するには、デバイスに次のソフトウェアがインストールされていることを確認します。
+ OpenCL バージョン 1.0 以降
+ Python 3.7 と pip
**注記**
デバイスが Python 3.6 で構築済みの場合は、代わりに Python 3.7 へのシンボリックリンクを作成することができます。詳細については、「[Step 2](#python-symlink)」を参照してください。
+ [NumPy](https://pypi.org/project/numpy/)
+ [ホイール上の OpenCV](https://pypi.org/project/opencv-python/)
1. Lambda 関数用に静的な PNG あるいは JPG 画像をダウンロードして、イメージ分類に使用します。この例は小さいイメージファイルで最適に動作します。
`greengrassObjectClassification.py` ファイルがあるディレクトリ (あるいは、このディレクトリのサブディレクトリ) に画像ファイルを保存します。これは、[ステップ 4: Lambda 関数を作成して発行する](#ml-console-create-lambda) でアップロードした Lambda 関数デプロイパッケージにあります。
**注記**
を使用している場合は AWS DeepLens、オンボードカメラを使用するか、独自のカメラをマウントして、静的イメージではなくキャプチャされたイメージに対して推論を実行できます。ただし、最初に静的イメージから開始することを強くお勧めします。
カメラを使用する場合は、`awscam` APT パッケージがインストールされていて、最新の状態であることを確認してください。詳細については、「AWS DeepLens デベロッパーガイド」の「[AWS DeepLens デバイスの更新](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html)」を参照してください。
1. Python 3.7 を使用していない場合は、Python 3.x から Python 3.7 へのシンボリックリンクを必ず作成します。これにより、 で Python 3 を使用するようにデバイスが設定されます AWS IoT Greengrass。次のコマンドを実行して、Python のインストールを検索します。
```
which python3
```
次のコマンドを実行して、シンボリックリンクを作成します。
```
sudo ln -s path-to-python-3.x/python3.x path-to-python-3.7/python3.7
```
デバイスを再起動します。
1. Lambda 関数の設定を編集します。「[ステップ 5: Lambda 関数を Greengrass グループに追加する](#ml-console-config-lambda)」の手順に従います。
**注記**
ビジネスケースで要求される場合を除き、Lambda 関数を、コンテナ化を使用しないで実行することをお勧めします。これにより、デバイスリソースを設定しなくても、デバイスの GPU とカメラにアクセスできるようになります。コンテナ化なしで を実行する場合は、 AWS IoT Greengrass Lambda 関数へのルートアクセスも許可する必要があります。
1. **コンテナ化を使用せずに実行するには:**
+ **[System user and group]** (システムユーザーとグループ) で、**Another user ID/group ID**を選択します。**[System user ID]** (システムユーザ ID) には、「**0**」と入力します。**[System group ID]** (システムグループ ID) には、「**0**」と入力します。
これにより、Lambda 関数を root として実行できます。root として実行の詳細については、「[グループ内の Lambda 関数に対するデフォルトのアクセス ID の設定](lambda-group-config.md#lambda-access-identity-groupsettings)」を参照してください。
**ヒント**
また、ルートアクセスを Lambda 関数に付与するように `config.json` ファイルを更新する必要があります。詳しい手順については、「[root としての Lambda 関数の実行](lambda-group-config.md#lambda-running-as-root)」を参照してください。
+ **[Lambda function containerization]** (Lambda 関数のコンテナ化) で、**[No container]** (コンテナなし) を選択します。
コンテナ化を使用しない実行の詳細については、「[Lambda 関数のコンテナ化を選択する場合の考慮事項](lambda-group-config.md#lambda-containerization-considerations)」を参照してください。
+ [**Timeout (タイムアウト)**] 値を 5 秒に更新します。これにより、リクエストの早過ぎるタイムアウトがなくなります。セットアップ後、推論の実行には数分かかります。
+ **[Pinned]**(固定)で、**[True]** を選択します。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
+ [**Lambda のライフサイクル**] で、[**存続期間が長く無制限に稼働する関数にする**] を選択します。
1. **代わりにコンテナ化モードで実行するには:**
**注記**
ビジネスケースで要求されない限り、コンテナ化モードでの実行はお勧めしていません。
+ [**Timeout (タイムアウト)**] 値を 5 秒に更新します。これにより、リクエストの早過ぎるタイムアウトがなくなります。セットアップ後、推論の実行には数分かかります。
+ **[Pinned]** (固定)で、**[True]** を選択します。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
1. **コンテナ化モードで実行している場合**、必要なローカルデバイスリソースを追加して、デバイス GPU へのアクセスを付与します。
**注記**
コンテナ化されていないモードで を実行すると、 AWS IoT Greengrass はデバイスリソースを設定せずにデバイス GPU にアクセスできます。
1. グループ設定ページで、**[Resources]** (リソース) タブを選択します。
1. **[Add local resource]** (ローカルリソースの追加) を選択します。
1. リソースを定義します。
+ **[リソース名]** に **renderD128** と入力します。
+ [**[Resource type]** (リソースタイプ) で、**[Local device]** (ローカルデバイス) を選択します。
+ [**デバイスパス**] に「**/dev/dri/renderD128**」と入力します。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
+ **[Lambda function affiliations]** (Lambda 関数の所属) で、Lambda 関数への **[Read and write access]** (読み取りと書き込みアクセス) を許可します。
## NVIDIA Jetson TX2 の設定
NVIDIA Jetson TX2 でこのチュートリアルを実行するには、ソースイメージを指定して、Lambda 関数を設定します。GPU を使用している場合、さらにローカルデバイスリソースを追加する必要があります。
1. AWS IoT Greengrass Core ソフトウェアをインストールできるように、Jetson デバイスが設定されていることを確認します。デバイスの設定の詳細については、「[他のデバイスの設定](setup-filter.other.md)」を参照してください。
1. MXNet のドキュメントを開き、[Jetson への MXNet のインストール](https://mxnet.apache.org/get_started/jetson_setup)に移動し、指示に従って Jetson デバイスに MXNet をインストールします。
**注記**
ソースから MXNet をビルドする場合は、指示に従って共有ライブラリをビルドします。`config.mk` ファイルの次の設定を編集して、Jetson TX2 デバイスを操作します。
`-gencode arch=compute-62, code=sm_62` を `CUDA_ARCH` 設定に追加します。
CUDA を有効にします。
```
USE_CUDA = 1
```
1. Lambda 関数用に静的な PNG あるいは JPG 画像をダウンロードして、イメージ分類に使用します。このアプリは小さな画像ファイルで最適に動作します。また、Jetson ボードにカメラを設置して、ソースイメージをキャプチャできます。
`greengrassObjectClassification.py` ファイルを含むディレクトリにイメージファイルを保存します。このディレクトリのサブディレクトリに保存することもできます。このディレクトリは、[ステップ 4: Lambda 関数を作成して発行する](#ml-console-create-lambda) でアップロードした Lambda 関数デプロイパッケージにあります。
1. Python 3.7 から Python 3.6 へのシンボリックリンクを作成して、 で Python 3 を使用します AWS IoT Greengrass。次のコマンドを実行して、Python のインストールを検索します。
```
which python3
```
次のコマンドを実行して、シンボリックリンクを作成します。
```
sudo ln -s path-to-python-3.6/python3.6 path-to-python-3.7/python3.7
```
デバイスを再起動します。
1. `ggc_user` システムアカウントが MXNet フレームワークを使用できることを確認します。
```
“sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
1. Lambda 関数の設定を編集します。「[ステップ 5: Lambda 関数を Greengrass グループに追加する](#ml-console-config-lambda)」の手順に従います。
**注記**
ビジネスケースで要求される場合を除き、Lambda 関数を、コンテナ化を使用しないで実行することをお勧めします。これにより、デバイスリソースを設定しなくても、デバイスの GPU とカメラにアクセスできるようになります。コンテナ化なしで を実行する場合は、 AWS IoT Greengrass Lambda 関数へのルートアクセスも許可する必要があります。
1. **コンテナ化を使用せずに実行するには:**
+ **[System user and group]** (システムユーザーとグループ) で、**Another user ID/group ID**を選択します。**[System user ID]** (システムユーザ ID) には、「**0**」と入力します。**[System group ID]** (システムグループ ID) には、「**0**」と入力します。
これにより、Lambda 関数を root として実行できます。root として実行の詳細については、「[グループ内の Lambda 関数に対するデフォルトのアクセス ID の設定](lambda-group-config.md#lambda-access-identity-groupsettings)」を参照してください。
**ヒント**
また、ルートアクセスを Lambda 関数に付与するように `config.json` ファイルを更新する必要があります。手順については、「[root としての Lambda 関数の実行](lambda-group-config.md#lambda-running-as-root)」を参照してください。
+ **[Lambda function containerization]** (Lambda 関数のコンテナ化) で、**[No container]** (コンテナなし) を選択します。
コンテナ化を使用しない実行の詳細については、「[Lambda 関数のコンテナ化を選択する場合の考慮事項](lambda-group-config.md#lambda-containerization-considerations)」を参照してください。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
+ **[Environment variables]** (環境変数) で、次のキーと値のペアを Lambda 関数に追加します。これにより、MXNet フレームワークを使用する AWS IoT Greengrass ように が設定されます。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/ml-console.html)
1. **代わりにコンテナ化モードで実行するには:**
**注記**
ビジネスケースで要求されない限り、コンテナ化モードでの実行はお勧めしていません。
+ [**メモリ制限**] の値を増やします。CPU の場合は 500 MB、GPU の場合は少なくとも 2000 MB を使用します。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
+ **[Environment variables]** (環境変数) で、次のキーと値のペアを Lambda 関数に追加します。これにより、MXNet フレームワークを使用する AWS IoT Greengrass ように が設定されます。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/ml-console.html)
1. **コンテナ化モードで実行している場合**、次のローカルデバイスリソースを追加して、デバイス GPU へのアクセスを許可します。「[ステップ 6: Greengrass グループにリソースを追加する](#ml-console-add-resources)」の手順に従います。
**注記**
コンテナ化されていないモードで を実行すると、 AWS IoT Greengrass はデバイスリソースを設定せずにデバイス GPU にアクセスできます。
リソースごとに:
+ **[リソースタイプ]** で、**[デバイス]** を選択します。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/ml-console.html)
1. **コンテナ化モードで実行している場合**で、次のローカルボリュームリソースを追加して、デバイスカメラへのアクセスを許可します。「[ステップ 6: Greengrass グループにリソースを追加する](#ml-console-add-resources)」の手順に従います。
**注記**
コンテナ化されていないモードで を実行すると、 AWS IoT Greengrass はボリュームリソースを設定せずにデバイスカメラにアクセスできます。
+ [**リソースタイプ**] で、[**ボリューム**] を選択します。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/ml-console.html)
# を使用して最適化された機械学習推論を設定する方法 AWS マネジメントコンソール
このチュートリアルのステップに従うには、 AWS IoT Greengrass Core v1.10 以降を使用する必要があります。
SageMaker AI Neo 深層学習コンパイラを使用すると、Tensorflow、Apache MXNet、PyTorch、ONNX、XGBoost フレームワークのネイティブ機械学習推論モデルの予測効率を最適化して、フットプリントを小さくし、パフォーマンスを向上させることができます。その後、最適化されたモデルをダウンロードして SageMaker AI Neo 深層学習ランタイムをインストールし、 AWS IoT Greengrass デバイスにデプロイして推論を高速化できます。
このチュートリアルでは、 を使用して、クラウド AWS マネジメントコンソール にデータを送信せずに、カメラからのイメージをローカルで認識する Lambda 推論の例を実行するように Greengrass グループを設定する方法について説明します。推論例では、Raspberry Pi のカメラモジュールにアクセスします。このチュートリアルでは、Resnet-50 によってトレーニングされて Neo 深層学習コンパイラで最適化された、事前にパッケージ化されたモデルをダウンロードします。次に、モデルを使用して AWS IoT Greengrass 、デバイスでローカルイメージ分類を実行します。
このチュートリアルのおおまかな手順は以下のとおりです。
1. [Raspberry Pi を設定する](#config-raspberry-pi-dlc)
1. [Neo 深層学習ランタイムをインストールする](#install-dlr)
1. [推論 Lambda 関数を作成する](#ml-console-dlc-create-lambda)
1. [グループに Lambda 関数を追加する](#ml-console-dlc-config-lambda)
1. [Neo 最適化モデルリソースをグループに追加する](#ml-console-dlc-add-resources)
1. [カメラデバイスリソースをグループに追加する](#ml-console-dlc-add-cam-resource)
1. [サブスクリプションをグループに追加する](#ml-console-dlc-add-subscription)
1. [グループをデプロイする](#ml-console-dlc-deploy-group)
1. [例をテストする](#ml-console-dlc-test-app)
## 前提条件
このチュートリアルを完了するには、以下が必要です。
+ Raspberry Pi 4 モデル B、または Raspberry Pi 3 モデル B/B\$1 は、 で使用するようにセットアップおよび設定されています AWS IoT Greengrass。Raspberry Pi を AWS IoT Greengrassと共にセットアップする前に、[Greengrass Device Setup](quick-start.md) スクリプトを実行するか、[の開始方法 AWS IoT Greengrass](gg-gs.md) の[モジュール 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) と[モジュール 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) を完了していることを確認します。
**注記**
Raspberry Pi では、イメージ分類に一般的に使用される深層学習のフレームワークを動かすために、2.5A の[電源](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/)が必要な場合があります。定格の低い電源を使用すると、デバイスが再起動する場合があります。
+ [Raspberry Pi カメラモジュール V2 - 8 メガピクセル、1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS)。カメラの設定方法については、Raspberry Pi ドキュメントで「[カメラの接続](https://www.raspberrypi.org/documentation/usage/camera/)」を参照してください。
+ Greengrass グループと Greengrass コア。Greengrass グループまたはコアを作成する方法については、「[の開始方法 AWS IoT Greengrass](gg-gs.md)」を参照してください。
**注記**
このチュートリアルでは Raspberry Pi を使用しますが、[Intel Atom](#atom-lambda-dlc-config) や [NVIDIA Jetson TX2 ](#jetson-lambda-dlc-config)などの他のプラットフォーム AWS IoT Greengrass をサポートしています。Intel Atom の例を使用する場合は、Python 3.7 ではなく Python 3.6 のインストールが必要な場合があります。 AWS IoT Greengrass Core ソフトウェアをインストールできるようにデバイスを設定する方法については、「」を参照してください[他のデバイスの設定](setup-filter.other.md)。
AWS IoT Greengrass がサポートしていないサードパーティープラットフォームの場合は、Lambda 関数をコンテナ化されていないモードで実行する必要があります。非コンテナ化モードで実行するには、Lambda 関数を root として実行する必要があります。詳細については、「[Lambda 関数のコンテナ化を選択する場合の考慮事項](lambda-group-config.md#lambda-containerization-considerations)」および「[グループ内の Lambda 関数に対するデフォルトのアクセス ID の設定](lambda-group-config.md#lambda-access-identity-groupsettings)」を参照してください。
## ステップ 1: Raspberry Pi を設定する
このステップでは、Raspbian オペレーティングシステムの更新プログラムをインストールし、カメラモジュールソフトウェアと Python の依存関係をインストールして、カメラインターフェイスを有効にします。
Raspberry Pi のターミナルで以下のコマンドを実行します。
1. Raspbian に更新プログラムをインストールします。
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. カメラモジュールの `picamera` インターフェイス、およびこのチュートリアルに必要なその他の Python ライブラリをインストールします。
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
インストールを検証します。
+ Python 3.7 のインストールに pip が含まれていることを確認します。
```
python3 -m pip
```
pip がインストールされていない場合は、[pip ウェブサイト](https://pip.pypa.io/en/stable/installing/)からダウンロードし、次のコマンドを実行します。
```
python3 get-pip.py
```
+ Python のバージョンが 3.7 以上であることを確認します。
```
python3 --version
```
出力に以前のバージョンが表示されている場合は、次のコマンドを実行します。
```
sudo apt-get install -y python3.7-dev
```
+ Setuptools と Picamera が正常にインストールされたことを確認します。
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
出力にエラーが含まれていない場合、検証は成功です。
**注記**
デバイスにインストールされている Python 実行可能ファイルが `python3.7` である場合は、このチュートリアルのコマンドに `python3` ではなく、`python3.7` を使用します。依存関係のエラーを回避するために、pip インストールが正しい `python3` バージョンまたは `python3.7` バージョンにマップされていることを確認してください。
1. Raspberry Pi を再起動します。
```
sudo reboot
```
1. Raspberry Pi 設定ツールを開きます。
```
sudo raspi-config
```
1. 矢印キーを使用して **[インターフェイスオプション]** を開き、カメラインターフェイスを有効にします。プロンプトが表示されたら、デバイスを再起動します。
1. 以下のコマンドを使用して、カメラの設定をテストします。
```
raspistill -v -o test.jpg
```
これにより、Raspberry Pi のプレビューウィンドウが開き、`test.jpg` という写真が現在のディレクトリに保存されて、カメラに関する情報が Raspberry Pi のターミナルに表示されます。
## ステップ 2: Amazon SageMaker Neo 深層学習ランタイムをインストールする
このステップでは、Neo 深層学習ランタイム (DLR) を Raspberry Pi にインストールドします。
**注記**
このチュートリアルでは、バージョン 1.1.0 をインストールすることをお勧めします。
1. リモートで Raspberry Pi にサインインします。
```
ssh pi@your-device-ip-address
```
1. DLR のドキュメントを開き、[DLR のインストール](https://neo-ai-dlr.readthedocs.io/en/latest/install.html)を開き、Raspberry Pi デバイスのホイール URL を見つけます。次に、指示に従って、デバイスに DLR をインストールします。例えば、pip を使用できます。
```
pip3 install rasp3b-wheel-url
```
1. DLR をインストールした後、次の設定を検証します。
+ `ggc_user` システムアカウントが DLR ライブラリを使用できることを確認します。
```
sudo -u ggc_user bash -c 'python3 -c "import dlr"'
```
+ NumPy がインストールされていることを確認します。
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## ステップ 3: 推論 Lambda 関数を作成する
この手順では、Lambda 関数デプロイパッケージと Lambda 関数を作成します。次に、関数のバージョンを公開し、エイリアスを作成します。
1. コンピュータで、[機械学習のサンプル](what-is-gg.md#gg-ml-samples) から Raspberry Pi の DLR サンプルをダウンロードします。
1. ダウンロードした `dlr-py3-armv7l.tar.gz` ファイルを解凍します。
```
cd path-to-downloaded-sample
tar -xvzf dlr-py3-armv7l.tar.gz
```
抽出されたサンプルパッケージの `examples` ディレクトリには、関数コードと依存関係が含まれています。
+ `inference.py` は、このチュートリアルで使用される推論コードです。このコードをテンプレートとして使用して、独自の推論関数を作成できます。
+ `greengrasssdk` は、 AWS IoT Greengrass Core SDK for Python のバージョン 1.5.0 です。
**注記**
新しいバージョンが利用できる場合は、そのバージョンをダウンロードし、デプロイパッケージ内の SDK バージョンをアップグレードできます。詳細については、GitHub の「[AWS IoT Greengrass Core SDK for Python](https://github.com/aws/aws-greengrass-core-sdk-python/)」を参照してください。
1. `examples` ディレクトリの内容を `optimizedImageClassification.zip` という名前のファイルに圧縮します。このファイルがデプロイパッケージです。
```
cd path-to-downloaded-sample/dlr-py3-armv7l/examples
zip -r optimizedImageClassification.zip .
```
デプロイメントパッケージには、関数コードと依存関係が含まれています。これには、Neo 深層学習ランタイム Python API を呼び出して、Neo 深層学習コンパイラモデルで推論を実行するコードが含まれます。
**注記**
`.py` ファイルと依存関係がディレクトリのルートにあることを確認します。
1. 次に、Lambda 関数を Greengrass グループに追加します。
[Lambda console](Lambda コンソール) ページから、**[Functions]** (関数)、**[Create function]** (関数の作成) の順に選択します。
1. **[一から作成]** を選択し、以下の値を使用して関数を作成します。
+ **[関数名]** に「**optimizedImageClassification**」と入力します。
+ **[ランタイム]** で **[Python 3.7]** を選択します。
**[アクセス許可]** はデフォルト設定のままにしておきます。これで Lambda への基本的なアクセス許可を付与する実行ロールが作成されます。このロールは では使用されません AWS IoT Greengrass。
![\[[関数の作成] ページの [Basic information] セクション。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/ml-dlc-inference/gg-dlr-lambda-creation.png)
1. [**関数の作成**] を選択してください。
今度は、Lambda 関数デプロイパッケージをアップロードし、ハンドラを登録します。
1. **[Code]** (コード) タブの **[Code source]** (コードソース) で、**[Upload from]** (アップロード元) を選択します。ドロップダウンから **[.zip ファイル]** を選択します。
![\[[.zip file] (.zip ファイル) が強調表示された [Upload from] (アップロード元) ドロップダウンリスト。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. `optimizedImageClassification.zip` デプロイパッケージを選択し、**[Save]** (保存) を選択します。
1. 関数の **[Code]** (コード) タブにある **[Runtime settings]** (ランタイム設定) で **[Edit]** (編集) を選択し、次の値を入力します。
+ **[ランタイム]** で **[Python 3.7]** を選択します。
+ **[ハンドラ]** に **inference.handler** と入力します。
**[保存]** を選択します。
![\[[Upload] (アップロード) が強調表示された [Runtime settings] (ランタイム設定) セクション。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-lambda-upload.png)
次に、Lambda 関数の最初のバージョンを発行します。その後、[バージョンのエイリアス](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html)を作成します。
**注記**
Greengrass グループは、Lambda 関数をエイリアス別 (推奨) またはバージョン別に参照できます。エイリアスを使用すると、関数コードを更新する時にサブスクリプションテーブルやグループ定義を変更する必要がないため、コード更新を簡単に管理できます。その代わりに、新しい関数バージョンにエイリアスを指定するだけで済みます。
1. **[アクション]** メニューから、**[新しいバージョンを発行]** を選択します。
![\[[アクション] メニューの [新しいバージョンを発行] オプション。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-publish-new.png)
1. **[バージョンの説明]** に **First version** と入力し、**[発行]** を選択します。
1. [**optimizedImageClassification: 1**] 設定ページで、[**Actions (アクション)**] メニューの [**エイリアスの作成**] を選択します。
![\[[アクション] メニューの [エイリアスの作成] オプション。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-create-alias.png)
1. **[新しいエイリアスの作成]** ページで、次の値を使用します。
+ [**名前**] に**mlTestOpt**と入力してください。
+ **[バージョン]** に **1** と入力します。
**注記**
AWS IoT Greengrass は、**\$1LATEST** バージョンの Lambda エイリアスをサポートしていません。
1. **[作成]** を選択します。
ここで、Greengrass グループに Lambda 関数を追加します。
## ステップ 4: Lambda 関数を Greengrass グループに追加する
このステップでは、Lambda 関数をグループに追加し、そのライフサイクルを設定します。
まず、Lambda 関数を Greengrass グループに追加します。
1. AWS IoT コンソールナビゲーションペインの**「管理**」で **Greengrass デバイス**を展開し、**「グループ (V1)**」を選択します。
1. グループ設定ページで、**[Lambda functions]** (Lambda 関数) タブ、**[Add]** (追加) の順に選択します。
1. **[Lambda function]** (Lambda 関数) と**[optimizedImageClassification]**を選択します。
1. **[Lambda function version]** (Lambda 関数のバージョン) で、公開したバージョンのエイリアスを選択します。
次に、Lambda 関数のライフサイクルを設定します。
1. **[Lambda function configuration]** (Lambda 関数の設定) セクションで次のように更新します。
**注記**
ビジネスケースで要求される場合を除き、Lambda 関数はコンテナ化を使用せずに実行することをお勧めします。これにより、デバイスリソースを設定しなくても、デバイスの GPU とカメラにアクセスできるようになります。コンテナ化なしで を実行する場合は、 AWS IoT Greengrass Lambda 関数へのルートアクセスも許可する必要があります。
1. **コンテナ化を使用せずに実行するには:**
+ **[System user and group]** (システムユーザーとグループ) で、**Another user ID/group ID**を選択します。**[System user ID]** (システムユーザ ID) には、「**0**」と入力します。**[System group ID]** (システムグループ ID) には、「**0**」と入力します。
これにより、Lambda 関数を root として実行できます。root として実行の詳細については、「[グループ内の Lambda 関数に対するデフォルトのアクセス ID の設定](lambda-group-config.md#lambda-access-identity-groupsettings)」を参照してください。
**ヒント**
また、ルートアクセスを Lambda 関数に付与するように `config.json` ファイルを更新する必要があります。手順については、「[root としての Lambda 関数の実行](lambda-group-config.md#lambda-running-as-root)」を参照してください。
+ **[Lambda function containerization]** (Lambda 関数のコンテナ化) で、**[No container]** (コンテナなし) を選択します。
コンテナ化を使用しない実行の詳細については、「[Lambda 関数のコンテナ化を選択する場合の考慮事項](lambda-group-config.md#lambda-containerization-considerations)」を参照してください。
+ **[タイムアウト]** に **10 seconds** と入力します。
+ **[固定]** で、**[True]** を選択します。
詳細については、「[Greengrass Lambda 関数のライフサイクル設定](lambda-functions.md#lambda-lifecycle)」を参照してください。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
1. **代わりにコンテナ化モードで実行するには:**
**注記**
ビジネスケースで要求されない限り、コンテナ化モードでの実行はお勧めしていません。
+ **[System user and group]** (システムユーザーとグループ) で、**[Use group default]** (グループのデフォルトを使用) を選択します。
+ **[Lambda function containerization]** (Lambda 関数のコンテナ化) で、**[Use group default]** (グループのデフォルトを使用) を選択します。
+ **[メモリ制限]** に **1024 MB** と入力します。
+ **[タイムアウト]** に **10 seconds** と入力します。
+ **[固定]** で、**[True]** を選択します。
詳細については、「[Greengrass Lambda 関数のライフサイクル設定](lambda-functions.md#lambda-lifecycle)」を参照してください。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
1. **[Add Lambda function]** (Lambda 関数の追加) を選択します。
## ステップ 5: Greengrass グループに SageMaker AI Neo 最適化モデルリソースを追加する
このステップでは、最適化された ML 推論モデルのリソースを作成して Amazon S3 バケットにアップロードします。次に、 AWS IoT Greengrass コンソールで Amazon S3 アップロードされたモデルを見つけ、新しく作成されたリソースを Lambda 関数に関連付けます。これにより、関数が Core デバイス上のリソースにアクセスできるようになります。
1. コンピュータで、「[ステップ 3: 推論 Lambda 関数を作成する](#ml-console-dlc-create-lambda)」で解凍したサンプルパッケージ内の `resnet50` ディレクトリに移動します。
**注記**
NVIDIA Jetson の例を使用する場合は、代わりにサンプルパッケージの `resnet18` ディレクトリを使用する必要があります。詳細については、「[NVIDIA Jetson TX2 の設定](#jetson-lambda-dlc-config)」を参照してください。
```
cd path-to-downloaded-sample/dlr-py3-armv7l/models/resnet50
```
このディレクトリには、Resnet-50 でトレーニングされたイメージ分類モデルのプリコンパイルされたモデルアーティファクトが含まれています。
1. `resnet50` ディレクトリ内のファイルを `resnet50.zip` という名前のファイルに圧縮します。
```
zip -r resnet50.zip .
```
1. グループのグループ設定ページで AWS IoT Greengrass 、**リソース**タブを選択します。[**Machine Learning (機械学習)**] セクションに移動し、[**機械学習リソースの追加**] を選択します。[**Create a machine learning resource (機械学習リソースの作成)**] ページで、[**Resource name (リソース名)**] に**resnet50\$1model** と入力します。
1. **[Model source]** (モデルソース) で、**[Use a model stored in S3, such as a model optimized through Deep Learning Compiler]** (深層学習コンパイラで最適化されたモデルなど、S3 に保存されているモデルを使用する) を選択します。
1. **[S3 URI]**から、選択 **[Browse S3]** (S3 の閲覧) を選択します。
**注記**
現在、最適化された SageMaker AI モデルは Amazon S3 に自動的に保存されます。このオプションを使用して、Amazon S3 バケット内の最適化されたモデルを見つけることができます。SageMaker AI でのモデル最適化の詳細については、[SageMaker AI Neo ドキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html)を参照してください。
1. [**モデルをアップロードする**] を選択します。
1. Amazon S3 コンソールタブで、zip ファイルを Amazon S3 バケットにアップロードします。詳細については、「Amazon Simple Storage Service ユーザーガイド」の「[S3 バケットにファイルとフォルダをアップロードする方法](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html)」を参照してください。
**注記**
バケット名には文字列 **greengrass** が含まれている必要があります。一意の名前 (**greengrass-dlr-bucket-*user-id*-*epoch-time*** など) を選択します。バケット名にピリオド (`.`) を使用しないでください。
1. AWS IoT Greengrass コンソールタブで、Amazon S3 バケットを見つけて選択します。アップロードした `resnet50.zip` ファイルを見つけ、**[選択]** を選択します。必要に応じてページを更新し、使用可能なバケットとファイルのリストを更新します。
1. **[Destination path]** (送信先) に「**/ml\$1model**」と入力します。
![\[更新された送信先。\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/images/ml-dlc-inference/local-path.png)
これは、Lambda ランタイム名前空間内のローカルモデルのターゲットです。グループをデプロイすると、 はソースモデルパッケージ AWS IoT Greengrass を取得し、指定したディレクトリにコンテンツを抽出します。
**注記**
ローカルパスに指定されている正確なパスを使用することを強くお勧めします。このステップで別のローカルモデルのターゲットパスを使用すると、このチュートリアルで示しているいくつかのトラブルシューティングコマンドが正確でなくなります。別のパスを使用する場合は、ここで指定する正確なパスを `MODEL_PATH` 環境変数に設定する必要があります。環境変数については、「[AWS Lambda 環境変数](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html)」を参照してください。
1. **コンテナ化モードで実行している場合:**
1. **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可) から、**[Specify system group and permissions]** (システムグループと権限を指定する) を選択します。
1. **[Read-only access]** (読み取り専用アクセス)、**[Add resources]** (リソースの追加) の順に選択します。
## ステップ 6: Greengrass グループにカメラデバイスリソースを追加する
このステップでは、カメラモジュールのリソースを作成し、Lambda 関数に関連付けます。これにより、Lambda 関数がコアデバイス上のリソースにアクセスできるようになります。
**注記**
コンテナ化されていないモードで を実行する場合、 AWS IoT Greengrass はこのデバイスリソースを設定せずにデバイス GPU とカメラにアクセスできます。
1. グループ設定ページで、**[Resources]** (リソース) タブを選択します。
1. **[Local resources]** (ローカルリソース) タブで、**[Add local resource]** (ローカルリソースの追加) を選択します。
1. **[Add a local resource]** (ローカルリソースの追加) ページで、次の値を使用します。
+ **[リソース名]** に **videoCoreSharedMemory** と入力します。
+ **[リソースタイプ]** で、**[デバイス]** を選択します。
+ **[Local device path]** (ローカルデバイスパス) には、「**/dev/vcsm**」と入力します。
デバイスパスはデバイスリソースのローカル絶対パスです。このパスは、`/dev` 下の文字デバイスまたはブロックデバイスのみを参照できます。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
[**Group owner file access permission**] (グループ所有者のファイルアクセス権限) オプションを使用すると、Lambda プロセスに追加のファイルアクセス権限を付与できます。詳細については、「[グループ所有者のファイルアクセス権限](access-local-resources.md#lra-group-owner)」を参照してください。
1. ページの下部で、[**Add resource**] (リソースの追加) を選択します。
1. **[Resources]** (リソース) タブから、**[Add]** (追加) を選択して、別のローカルリソースを作成し、次の値を使用します。
+ **[リソース名]** に **videoCoreInterface** と入力します。
+ **[リソースタイプ]** で、**[デバイス]** を選択します。
+ **[Local device path]** (ローカルデバイスパス) には、「**/dev/vchiq**」と入力します。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
1. **[リソースを追加]** を選択します。
## ステップ 7: サブスクリプションを Greengrass グループに追加する
このステップでは、グループにサブスクリプションを追加します。これらのサブスクリプションにより、Lambda 関数は MQTT トピックに発行 AWS IoT して予測結果を に送信できます。
1. グループ設定ページで、**[Subscriptions]** (サブスクリプション) タブ、**[Add subscription]** (サブスクリプションの追加) の順に選択します。
1. **[Create a subscription]** (サブスクリプションの作成) ページで、ソースおよびターゲットを次のように設定します。
1. **[Source type]** (ソースタイプ) で、**[Lambda function]** (Lambda 関数)、**[optimizedImageClassification]** の順に選択します。
1. **[Target type]** (ターゲットタイプ)で、**[Service]** (サービス)、**[IoT Cloud]** (IoT クラウド) の順に選択します。
1. **[Topic filter]** (トピックのフィルター) で、「**/resnet-50/predictions**」と入力し、**[Create subscription]** (サブスクリプションの作成) を選択します。
1. 2 つ目のサブスクリプションを追加します。**[Subscriptions]** (サブスクリプション) タブ、**[Add subscription]** (サブスクリプションの追加) の順に選択し、ソースとターゲットを次のように設定します。
1. **[Source type]** (ソースタイプ) で、**[Service]** (サービス)、**[IoT Cloud]** (IoT クラウド) の順に選択します。
1. **[Target type]** (ターゲットタイプ) で、**[Lambda function]** (Lambda 関数)、**[optimizedImageClassification]** の順に選択します。
1. **[Topic filter]** (トピックのフィルター) で、「**/resnet-50/test**」と入力し、**[Create subscription]** (サブスクリプションの作成) を選択します。
## ステップ 8: Greengrass グループをデプロイする
このステップでは、グループ定義の現在のバージョンを Greengrass コアデバイスにデプロイします。この定義には、追加した Lambda 関数、リソース、サブスクリプション設定が含まれます。
1. AWS IoT Greengrass コアが実行されていることを確認します。必要に応じて、Raspberry Pi のターミナルで以下のコマンドを実行します。
1. デーモンが実行中かどうかを確認するには、以下を実行します。
```
ps aux | grep -E 'greengrass.*daemon'
```
出力に `root` で実行中の `/greengrass/ggc/packages/latest-core-version/bin/daemon` のエントリが含まれていれば、デーモンは実行されています。
1. デーモンを開始するには、以下を実行します。
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. グループ設定ページで、**[Deploy]** (デプロイ) を選択します。
1. **[Lambda functions]** (Lambda 関数) タブで、**[IP detector]** (IP ディテクター)と **[Edit]** (編集) を選択します。
1. **[Edit IP detector settings]** (IP ディテクター設定の編集) のダイアログボックスで、**[Automatically detect and override MQTT broker endpoints]** (MQTT ブローカーのエンドポイントを自動的に検出して上書きする) と、**Save** (保存) を選択します。
これにより、デバイスは、IP アドレス、DNS、ポート番号など、コアの接続情報を自動的に取得できます。自動検出が推奨されますが、手動で指定されたエンドポイント AWS IoT Greengrass もサポートされます。グループが初めてデプロイされたときにのみ、検出方法の確認が求められます。
**注記**
プロンプトが表示されたら、[Greengrass サービスロール](service-role.md)を作成し、それを現在の AWS アカウント の に関連付けるアクセス許可を付与します AWS リージョン。このロールにより AWS IoT Greengrass 、 は AWS サービスのリソースにアクセスできます。
**[デプロイ]** ページには、デプロイのタイムスタンプ、バージョン ID、ステータスが表示されます。完了すると、デプロイのステータスが **[Completed]** (完了) と表示されます。
デプロイの詳細については、「[AWS IoT Greengrass コアに AWS IoT Greengrass グループをデプロイする](deployments.md)」を参照してください。トラブルシューティングのヘルプについては、[トラブルシューティング AWS IoT Greengrass](gg-troubleshooting.md) を参照してください。
## 推論例をテストする
これで、デプロイが正しく設定されているかどうかを確認できます。テストするには、`/resnet-50/predictions` トピックにサブスクライブし、`/resnet-50/test` トピックにメッセージを発行します。これにより、Raspberry Pi で写真を撮影してキャプチャしたイメージの推論を実行する Lambda 関数がトリガーされます。
**注記**
NVIDIA Jetson の例を使用する場合は、代わりに `resnet-18/predictions` トピックおよび `resnet-18/test` トピックを使用してください。
**注記**
モニターが Raspberry Pi に接続されている場合、ライブカメラのフィードがプレビューウィンドウに表示されます。
1. AWS IoT コンソールのホームページの**テスト**で、**MQTT テストクライアント**を選択します。
1. **[Subscriptions]** (サブスクリプション) で、**[Subscribe to a Topic]** (トピックへのサブスクライブ) を選択します。以下の値を使用します。残りのオプションはデフォルトのままにします。
+ [**Subscription topic (サブスクリプショントピック)**] で、**/resnet-50/predictions** と入力します。
+ **[Additional configuration]** (追加設定) から、**[MQTT payload display]** (MQTT ペイロード表示) で、**[Display payloads as strings]** (文字列としてペイロードを表示) を選択します。
1. **[サブスクライブ]** を選択します。
1. **[Publish to a topic]** (トピックに公開) を選択して、**[Topic name]** (トピック名) として「**/resnet-50/test**」を入力し、**[Publish]** (発行) を選択します。
1. テストが成功すると、発行されたメッセージによって Raspberry Pi カメラがイメージをキャプチャします。Lambda 関数からのメッセージがページの下部に表示されます。このメッセージには、予測クラス名、確率、最大メモリ使用量の形式で、イメージの予測結果が含まれています。
## インテル Atom の設定
Intel Atom デバイスでこのチュートリアルを実行するには、ソースイメージを指定し、Lambda 関数を設定して、別のローカルデバイスリソースを追加する必要があります。GPU を推論に使用するには、デバイスに次のソフトウェアがインストールされていることを確認します。
+ OpenCL バージョン 1.0 以降
+ Python 3.7 と pip
+ [NumPy](https://pypi.org/project/numpy/)
+ [ホイール上の OpenCV](https://pypi.org/project/opencv-python/)
1. Lambda 関数用に静的な PNG あるいは JPG 画像をダウンロードして、イメージ分類に使用します。この例は小さいイメージファイルで最適に動作します。
`inference.py` ファイルがあるディレクトリ (あるいは、このディレクトリのサブディレクトリ) に画像ファイルを保存します。これは、[ステップ 3: 推論 Lambda 関数を作成する](#ml-console-dlc-create-lambda) でアップロードした Lambda 関数デプロイパッケージにあります。
**注記**
を使用している場合は AWS DeepLens、オンボードカメラを使用するか、独自のカメラをマウントして、静的イメージではなくキャプチャされたイメージに対して推論を実行できます。ただし、最初に静的イメージから開始することを強くお勧めします。
カメラを使用する場合は、`awscam` APT パッケージがインストールされていて、最新の状態であることを確認してください。詳細については、「AWS DeepLens デベロッパーガイド」の「[AWS DeepLens デバイスの更新](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html)」を参照してください。
1. Lambda 関数の設定を編集します。「[ステップ 4: Lambda 関数を Greengrass グループに追加する](#ml-console-dlc-config-lambda)」の手順に従います。
**注記**
ビジネスケースで要求される場合を除き、Lambda 関数を、コンテナ化を使用しないで実行することをお勧めします。これにより、デバイスリソースを設定しなくても、デバイスの GPU とカメラにアクセスできるようになります。コンテナ化なしで を実行する場合は、 AWS IoT Greengrass Lambda 関数へのルートアクセスも許可する必要があります。
1. **コンテナ化を使用せずに実行するには:**
+ **[System user and group]** (システムユーザーとグループ) で、**Another user ID/group ID**を選択します。**[System user ID]** (システムユーザ ID) には、「**0**」と入力します。**[System group ID]** (システムグループ ID) には、「**0**」と入力します。
これにより、Lambda 関数を root として実行できます。root として実行の詳細については、「[グループ内の Lambda 関数に対するデフォルトのアクセス ID の設定](lambda-group-config.md#lambda-access-identity-groupsettings)」を参照してください。
**ヒント**
また、ルートアクセスを Lambda 関数に付与するように `config.json` ファイルを更新する必要があります。手順については、「[root としての Lambda 関数の実行](lambda-group-config.md#lambda-running-as-root)」を参照してください。
+ **[Lambda function containerization]** (Lambda 関数のコンテナ化) で、**[No container]** (コンテナなし) を選択します。
コンテナ化を使用しない実行の詳細については、「[Lambda 関数のコンテナ化を選択する場合の考慮事項](lambda-group-config.md#lambda-containerization-considerations)」を参照してください。
+ [**タイムアウト**] の値を 2 分に増やします。これにより、リクエストの早過ぎるタイムアウトがなくなります。セットアップ後、推論の実行には数分かかります。
+ **[Pinned]** (固定)で、**[True]** を選択します。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
1. **代わりにコンテナ化モードで実行するには:**
**注記**
ビジネスケースで要求されない限り、コンテナ化モードでの実行はお勧めしていません。
+ [**メモリ制限**] の値を 3000 MB に増やします。
+ [**タイムアウト**] の値を 2 分に増やします。これにより、リクエストの早過ぎるタイムアウトがなくなります。セットアップ後、推論の実行には数分かかります。
+ **[Pinned]** (固定)で、**[True]** を選択します。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
1. Neo 最適化モデルリソースをグループに追加します。[ステップ 3: 推論 Lambda 関数を作成する](#ml-console-dlc-create-lambda) で解凍したサンプルパッケージの `resnet50` ディレクトリにモデルリソースをアップロードします。このディレクトリには、Resnet-50 でトレーニングされたイメージ分類モデルのプリコンパイルされたモデルアーティファクトが含まれています。次の更新で、[ステップ 5: Greengrass グループに SageMaker AI Neo 最適化モデルリソースを追加する](#ml-console-dlc-add-resources) の手順に従います。
+ `resnet50` ディレクトリ内のファイルを `resnet50.zip` という名前のファイルに圧縮します。
+ [**Create a machine learning resource (機械学習リソースの作成)**] ページで、[**Resource name (リソース名)**] に**resnet50\$1model** と入力します。
+ `resnet50.zip` ファイルをアップロードします。
1. **コンテナ化モードで実行している場合**、必要なローカルデバイスリソースを追加して、デバイス GPU へのアクセスを付与します。
**注記**
コンテナ化されていないモードで を実行すると、 AWS IoT Greengrass はデバイスリソースを設定せずにデバイス GPU にアクセスできます。
1. グループ設定ページで、**[Resources]** (リソース) タブを選択します。
1. **[Local resources]** (ローカルリソース) タブで、**[Add local resource]** (ローカルリソースの追加) を選択します。
1. リソースを定義します。
+ **[リソース名]** に **renderD128** と入力します。
+ **[リソースタイプ]** で、**[デバイス]** を選択します。
+ **[Local device path]** (ローカルデバイスパス) には、「**/dev/dri/renderD128**」と入力します。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
## NVIDIA Jetson TX2 の設定
NVIDIA Jetson TX2 でこのチュートリアルを実行するには、ソースイメージを指定して、Lambda 関数を設定し、さらにローカルデバイスリソースを追加します。
1. Core AWS IoT Greengrass ソフトウェアをインストールし、推論に GPU を使用できるように、Jetson デバイスが設定されていることを確認します。デバイスの設定の詳細については、「[他のデバイスの設定](setup-filter.other.md)」を参照してください。NVIDIA Jetson TX2 で推論に GPU を使用するには、Jetpack 4.3 でボードのイメージを作成するときに、デバイスに CUDA 10.0 と cuDNN 7.0 をインストールする必要があります。
1. Lambda 関数用に静的な PNG あるいは JPG 画像をダウンロードして、イメージ分類に使用します。この例は小さいイメージファイルで最適に動作します。
`inference.py` ファイルを含むディレクトリにイメージファイルを保存します。このディレクトリのサブディレクトリに保存することもできます。このディレクトリは、[ステップ 3: 推論 Lambda 関数を作成する](#ml-console-dlc-create-lambda) でアップロードした Lambda 関数デプロイパッケージにあります。
**注記**
代わりに、Jetson ボードにカメラを設置して、ソースイメージをキャプチャすることもできます。ただし、最初に静的イメージから開始することを強くお勧めします。
1. Lambda 関数の設定を編集します。「[ステップ 4: Lambda 関数を Greengrass グループに追加する](#ml-console-dlc-config-lambda)」の手順に従います。
**注記**
ビジネスケースで要求される場合を除き、Lambda 関数を、コンテナ化を使用しないで実行することをお勧めします。これにより、デバイスリソースを設定しなくても、デバイスの GPU とカメラにアクセスできるようになります。コンテナ化なしで を実行する場合は、 AWS IoT Greengrass Lambda 関数へのルートアクセスも許可する必要があります。
1. **コンテナ化を使用せずに実行するには:**
+ **[Run as]** (として実行) に、「**Another user ID/group ID**」を選択します。**[UID]** に、「**0**」と入力します。**[GUID]** に、「**0**」と入力します。
これにより、Lambda 関数を root として実行できます。root として実行の詳細については、「[グループ内の Lambda 関数に対するデフォルトのアクセス ID の設定](lambda-group-config.md#lambda-access-identity-groupsettings)」を参照してください。
**ヒント**
また、ルートアクセスを Lambda 関数に付与するように `config.json` ファイルを更新する必要があります。手順については、「[root としての Lambda 関数の実行](lambda-group-config.md#lambda-running-as-root)」を参照してください。
+ **[Lambda function containerization]** (Lambda 関数のコンテナ化) で、**[No container]** (コンテナなし) を選択します。
コンテナ化を使用しない実行の詳細については、「[Lambda 関数のコンテナ化を選択する場合の考慮事項](lambda-group-config.md#lambda-containerization-considerations)」を参照してください。
+ [**タイムアウト**] の値を 5 分に増やします。これにより、リクエストの早過ぎるタイムアウトがなくなります。セットアップ後、推論の実行には数分かかります。
+ **[Pinned]** (固定)で、**[True]** を選択します。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
1. **代わりにコンテナ化モードで実行するには:**
**注記**
ビジネスケースで要求されない限り、コンテナ化モードでの実行はお勧めしていません。
+ [**メモリ制限**] の値を増やします。指定されたモデルを GPU モードで使用するには、少なくとも 2000 MB を使用します。
+ [**タイムアウト**] の値を 5 分に増やします。これにより、リクエストの早過ぎるタイムアウトがなくなります。セットアップ後、推論の実行には数分かかります。
+ **[Pinned]** (固定)で、**[True]** を選択します。
+ **[Additional Parameter]** (追加のパラメータ) の、**[Read access to /sys directory]** (/sys ディレクトリへの読み取りアクセス) で、**[Enabled]** (有効) を選択します。
1. Neo 最適化モデルリソースをグループに追加します。[ステップ 3: 推論 Lambda 関数を作成する](#ml-console-dlc-create-lambda) で解凍したサンプルパッケージの `resnet18` ディレクトリにモデルリソースをアップロードします。このディレクトリには、Resnet-18 でトレーニングされたイメージ分類モデルのプリコンパイル済みのモデルアーティファクトが含まれています。次の更新で、[ステップ 5: Greengrass グループに SageMaker AI Neo 最適化モデルリソースを追加する](#ml-console-dlc-add-resources) の手順に従います。
+ `resnet18` ディレクトリ内のファイルを `resnet18.zip` という名前のファイルに圧縮します。
+ [**Create a machine learning resource (機械学習リソースの作成)**] ページで、[**Resource name (リソース名)**] に**resnet18\$1model** と入力します。
+ `resnet18.zip` ファイルをアップロードします。
1. **コンテナ化モードで実行している場合**、必要なローカルデバイスリソースを追加して、デバイス GPU へのアクセスを付与します。
**注記**
コンテナ化されていないモードで を実行すると、 AWS IoT Greengrass はデバイスリソースを設定せずにデバイス GPU にアクセスできます。
1. グループ設定ページで、**[Resources]** (リソース) タブを選択します。
1. **[Local resources]** (ローカルリソース) タブで、**[Add local resource]** (ローカルリソースの追加) を選択します。
1. 各リソースを定義します。
+ [**リソース名**] と [**デバイスパス**] には、次の表の値を使用します。テーブルの行ごとに 1 つのデバイスリソースを作成します。
+ **[リソースタイプ]** で、**[デバイス]** を選択します。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/ml-dlc-console.html)
1. **コンテナ化モードで実行している場合**で、次のローカルボリュームリソースを追加して、デバイスカメラへのアクセスを許可します。「[ステップ 5: Greengrass グループに SageMaker AI Neo 最適化モデルリソースを追加する](#ml-console-dlc-add-resources)」の手順に従います。
**注記**
コンテナ化されていないモードで を実行する場合、 AWS IoT Greengrass はデバイスリソースを設定せずにデバイスカメラにアクセスできます。
+ [**リソースタイプ**] で、[**ボリューム**] を選択します。
+ **[System group owner and file access permissions]** (システムグループ所有者のファイルアクセス許可)で、**[Automatically add file system permissions of the system group that owns the resource]** (リソースを所有するシステムグループのファイルシステム権限を自動的に追加する) を選択します。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ja_jp/greengrass/v1/developerguide/ml-dlc-console.html)
1. 正しいディレクトリを使用するようにグループサブスクリプションを更新します。次の更新で、[ステップ 7: サブスクリプションを Greengrass グループに追加する](#ml-console-dlc-add-subscription) の手順に従います。
+ 最初のトピックフィルタには、**/resnet-18/predictions** と入力します。
+ 2 番目のトピックフィルタには、**/resnet-18/test** と入力します。
1. 正しいディレクトリを使用するようにテストサブスクリプションを更新します。次の更新で、[推論例をテストする](#ml-console-dlc-test-app) の手順に従います。
+ **[Subscriptions]** (サブスクリプション) で、**[Subscribe to a Topic]** (トピックへのサブスクライブ) を選択します。[**Subscription topic (サブスクリプショントピック)**] で、**/resnet-18/predictions** と入力します。
+ `/resnet-18/predictions` ページで、発行先の `/resnet-18/test` トピックを指定します。
## ML AWS IoT Greengrass 推論のトラブルシューティング
テストに成功しなかった場合は、以下のトラブルシューティング手順を実行できます。Raspberry Pi のターミナルで以下のコマンドを実行します。
### エラーログを確認する
1. root ユーザーに切り替え、`log` ディレクトリに移動します。 AWS IoT Greengrass ログにアクセスするには、ルートアクセス許可が必要です。
```
sudo su
cd /greengrass/ggc/var/log
```
1. `runtime.log` でエラーがないかどうかを確認します。
```
cat system/runtime.log | grep 'ERROR'
```
ユーザー定義の Lambda 関数ログでもエラーがないかどうかを確認できます。
```
cat user/your-region/your-account-id/lambda-function-name.log | grep 'ERROR'
```
詳細については、「[ログによるトラブルシューティング](gg-troubleshooting.md#troubleshooting-logs)」を参照してください。
### Lambda 関数が正常にデプロイされていることを確認する
1. `/lambda` ディレクトリ内のデプロイされた Lambda の内容を一覧表示します。コマンドを実行する前に、プレースホルダーの値を置き換えてください。
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. ディレクトリに、[ステップ 3: 推論 Lambda 関数を作成する](#ml-console-dlc-create-lambda) でアップロードした `optimizedImageClassification.zip` デプロイパッケージと同じ内容が含まれることを確認します。
`.py` ファイルと依存関係がディレクトリのルートにあることを確認します。
### 推論モデルが正常にデプロイされていることを確認する
1. Lambda ランタイムプロセスのプロセス識別番号 (PID) を見つけます。
```
ps aux | grep lambda-function-name
```
出力では、Lambda ランタイムプロセスの行の 2 列目に PID が表示されます。
1. Lambda ランタイム名前空間を入力します。コマンドを実行する前に、*pid* プレースホルダーの値を置き換えてください。
**注記**
このディレクトリとその内容は、Lambda ランタイム名前空間にあるため、通常の Linux 名前空間には表示されません。
```
sudo nsenter -t pid -m /bin/bash
```
1. ML リソース用に指定したローカルディレクトリの内容を一覧表示します。
**注記**
ML リソースのパスが `ml_model` 以外の場合は、ここで置き換えてください。
```
cd /ml_model
ls -ls
```
以下のファイルが表示されます。
```
56 -rw-r--r-- 1 ggc_user ggc_group 56703 Oct 29 20:07 model.json
196152 -rw-r--r-- 1 ggc_user ggc_group 200855043 Oct 29 20:08 model.params
256 -rw-r--r-- 1 ggc_user ggc_group 261848 Oct 29 20:07 model.so
32 -rw-r--r-- 1 ggc_user ggc_group 30564 Oct 29 20:08 synset.txt
```
### Lambda 関数で `/dev/dri/renderD128` が見つからない
このエラーは、OpenCL から必要な GPU デバイスに接続できない場合に発生します。Lambda 関数に必要なデバイスでデバイスリソースを作成する必要があります。
## 次の手順
次は、最適化された他のモデルを試します。詳細については、[SageMaker AI Neo ドキュメント](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html)を参照してください。