Hinweis zum Ende des Supports: Am 7. Oktober 2026 AWS wird der Support für eingestellt. AWS IoT Greengrass Version 1 Nach dem 7. Oktober 2026 können Sie nicht mehr auf die Ressourcen zugreifen. AWS IoT Greengrass V1 Weitere Informationen finden Sie unter [Migrieren von AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Durchführen von Machine Learning-Inferenzen
Diese Funktion ist für AWS IoT Greengrass Core v1.6 oder höher verfügbar.
Mit AWS IoT Greengrass können Sie maschinelles Lernen (ML) direkt am Netzwerkrand anhand lokal generierter Daten mithilfe von in der Cloud trainierten Modellen ableiten. Sie können von der niedrigen Latenz und Kosteneinsparungen der Ausführung von lokaler Inferenz profitieren und trotzdem die Cloud-Rechenleistung für Schulungsmodelle und komplexe Verarbeitung nutzen.
Hinweise zur Durchführung von lokaler Inferenz finden Sie unter [So konfigurieren Sie die Inferenz für maschinelles Lernen mit dem AWS-Managementkonsole](ml-console.md).
## Wie funktioniert AWS IoT Greengrass ML-Inferenz
Sie können Ihre Inferenzmodelle überall trainieren, sie lokal als *Ressourcen für maschinelles Lernen* in einer Greengrass-Gruppe bereitstellen und dann über Greengrass Lambda-Funktionen auf sie zugreifen. Sie können beispielsweise Deep-Learning-Modelle in [SageMaker KI](https://console.aws.amazon.com/sagemaker) erstellen und trainieren und sie auf Ihrem Greengrass-Kern einsetzen. Anschließend können Ihre Lambda-Funktionen die lokalen Modelle verwenden, um Inferenzen auf verbundenen Geräten durchzuführen und neue Trainingsdaten zurück in die Cloud zu senden.
Das folgende Diagramm zeigt den AWS IoT Greengrass ML-Inferenz-Workflow.
![\[Komponenten des Workflows für maschinelles Lernen und des Informationsflusses zwischen den zentralen Geräten, dem AWS IoT Greengrass Dienst und den in der Cloud trainierten Modellen.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/ml-inference/diagram-ml-overview.png)
AWS IoT Greengrass ML-Inferenz vereinfacht jeden Schritt des ML-Workflows, einschließlich:
+ Die Entwicklung und Bereitstellung von ML-Framework-Prototypen.
+ Der Zugriff auf Cloud-geschulte Modelle und die deren Bereitstellung in Greengrass Core-Geräten.
+ [Erstellung von Inferenz-Apps, die auf Hardwarebeschleuniger (wie GPUs und FPGAs) als lokale Ressourcen zugreifen können.](access-local-resources.md)
## Machine Learning-Ressourcen
Ressourcen für maschinelles Lernen stellen in der Cloud trainierte Inferenzmodelle dar, die für einen Kern bereitgestellt werden. AWS IoT Greengrass Um Ressourcen für maschinelles Lernen bereitzustellen, fügen Sie die Ressourcen zunächst einer Greengrass-Gruppe hinzu und definieren dann, wie Lambda-Funktionen in der Gruppe auf sie zugreifen können. AWS IoT Greengrass Ruft während der Gruppenbereitstellung die Quellmodellpakete aus der Cloud ab und extrahiert sie in Verzeichnisse innerhalb des Lambda-Laufzeit-Namespace. Anschließend verwenden die Lambda-Funktionen von Greengrass die lokal bereitgestellten Modelle, um Inferenzen durchzuführen.
Um ein lokal bereitgestelltes Modell zu aktualisieren, aktualisieren Sie zuerst das Quellmodell (in der Cloud), das mit der Machine Learning-Ressource übereinstimmt, und stellen Sie dann die Gruppe bereit. Während der Bereitstellung überprüft AWS IoT Greengrass die Quelle auf Änderungen. Wenn Änderungen erkannt werden, wird das lokale AWS IoT Greengrass Modell aktualisiert.
### Unterstützte Modellquellen
AWS IoT Greengrass unterstützt SageMaker KI- und Amazon S3 S3-Modellquellen für Ressourcen für maschinelles Lernen.
Die folgenden Anforderungen gelten für Modellquellen:
+ S3-Buckets, in denen Ihre SageMaker KI- und Amazon S3 S3-Modellquellen gespeichert sind, dürfen nicht mit SSE-C verschlüsselt werden. Für Buckets, die serverseitige Verschlüsselung verwenden, unterstützt AWS IoT Greengrass ML-Inferenz derzeit nur die Verschlüsselungsoptionen SSE-S3 oder SSE-KMS. Weitere Informationen zu serverseitigen Verschlüsselungsoptionen finden Sie unter [Schützen von Daten mithilfe serverseitiger Verschlüsselung](https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.
+ Die Namen der S3-Buckets, in denen Ihre SageMaker KI- und Amazon S3 S3-Modellquellen gespeichert sind, dürfen keine Punkte (`.`) enthalten. Weitere Informationen finden Sie in der Regel zur Verwendung von Buckets im virtuellen Hosted-Stil mit SSL unter [Regeln für die Bucket-Benennung](https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html#bucketnamingrules) im *Amazon Simple Storage Service-Benutzerhandbuch*.
+ [Service AWS-Region Level-Support muss sowohl für KI als auch für KI verfügbar sein. [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)SageMaker ](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html) AWS IoT Greengrass Unterstützt derzeit SageMaker KI-Modelle in den folgenden Regionen:
+ US East (Ohio)
+ USA Ost (Nord-Virginia)
+ USA West (Oregon)
+ Asia Pacific (Mumbai)
+ Asia Pacific (Seoul)
+ Asien-Pazifik (Singapur)
+ Asien-Pazifik (Sydney)
+ Asien-Pazifik (Tokio)
+ Europe (Frankfurt)
+ Europa (Irland)
+ Europa (London)
+ AWS IoT Greengrass muss über `read` Berechtigungen für die Modellquelle verfügen, wie in den folgenden Abschnitten beschrieben.
**SageMaker AI**
AWS IoT Greengrass unterstützt Modelle, die als SageMaker KI-Trainingsjobs gespeichert wurden. SageMaker KI ist ein vollständig verwalteter ML-Service, mit dem Sie Modelle mithilfe integrierter oder benutzerdefinierter Algorithmen erstellen und trainieren können. Weitere Informationen finden Sie unter [Was ist SageMaker KI?](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) im *SageMaker AI Developer Guide*.
Wenn Sie Ihre SageMaker KI-Umgebung konfiguriert haben, indem Sie [einen Bucket erstellt](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-config-permissions.html) haben, dessen Name enthält`sagemaker`, dann AWS IoT Greengrass über ausreichende Berechtigungen für den Zugriff auf Ihre SageMaker KI-Schulungsjobs verfügt. Die verwaltete Richtlinie `AWSGreengrassResourceAccessRolePolicy` erlaubt den Zugriff auf Buckets, deren Name die Zeichenfolge `sagemaker` enthält. Diese Richtlinie ist der [Greengrass-Servicerolle](service-role.md) angefügt.
Andernfalls müssen Sie dem Bucket, in dem Ihr Trainingsjob gespeichert ist, die AWS IoT Greengrass `read` Erlaubnis erteilen. Betten Sie zu diesem Zweck die folgende eingebundene Richtlinie in die Greengrass-Servicerolle ein. Sie können mehrere Buckets auflisten ARNs.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
**Amazon S3**
AWS IoT Greengrass unterstützt Modelle, die in Amazon S3 als `tar.gz` `.zip` OR-Dateien gespeichert sind.
Um auf Modelle zugreifen AWS IoT Greengrass zu können, die in Amazon S3 S3-Buckets gespeichert sind, müssen Sie die AWS IoT Greengrass `read` Erlaubnis zum Zugriff auf die Buckets erteilen, indem Sie **einen der folgenden** Schritte ausführen:
+ Speichern Sie Ihr Modell in einem Bucket, dessen Name `greengrass` enthält.
Die verwaltete Richtlinie `AWSGreengrassResourceAccessRolePolicy` erlaubt den Zugriff auf Buckets, deren Name die Zeichenfolge `greengrass` enthält. Diese Richtlinie ist der [Greengrass-Servicerolle](service-role.md) angefügt.
+ Betten Sie eine eingebundene Richtlinie in die Greengrass-Service-Rolle ein.
Wenn Ihr Bucket-Name nicht `greengrass` enthält, fügen Sie die folgende eingebundene Richtlinien der Service-Rolle hinzu. Sie können mehrere Buckets auflisten. ARNs
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
------
Weitere Informationen finden Sie unter [Einbetten von Inline-Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console) im *IAM-Benutzerhandbuch*.
## Voraussetzungen
Die folgenden Anforderungen gelten für die Erstellung und Verwendung von Machine Learning-Ressourcen:
+ Sie müssen AWS IoT Greengrass Core v1.6 oder höher verwenden.
+ Benutzerdefinierte Lambda-Funktionen können `read and write` OR-Operationen auf der `read` Ressource ausführen. Berechtigungen für andere Operationen sind nicht verfügbar. Der Containerisierungsmodus verbundener Lambda-Funktionen bestimmt, wie Sie Zugriffsberechtigungen festlegen. Weitere Informationen finden Sie unter [Greifen Sie über Lambda-Funktionen auf Ressourcen für maschinelles Lernen zu](access-ml-resources.md).
+ Sie müssen den vollständigen Pfad der Ressource im Betriebssystem des Core-Geräts bereitstellen.
+ Der Name oder die ID einer Ressource kann maximal 128 Zeichen umfassen und muss dem Muster `[a-zA-Z0-9:_-]+` entsprechen.
## Laufzeiten und Bibliotheken für ML-Inferenz
Sie können die folgenden ML-Laufzeiten und -Bibliotheken mit verwenden. AWS IoT Greengrass
+ [Deep-Learning-Laufzeit von Amazon SageMaker Neo](#dlc-optimize-info)
+ Apache MXNet
+ TensorFlow
Diese Laufzeiten und Bibliotheken können auf den Plattformen NVIDIA Jetson TX2, Intel Atom und Raspberry Pi installiert werden. Informationen zum Download finden Sie unter [Unterstützte Machine Learning-Laufzeiten und -Bibliotheken](what-is-gg.md#ml-runtimes-libs). Sie können sie direkt auf Ihrem Core-Gerät installieren.
Lesen Sie die folgenden Informationen zu Kompatibilität und Einschränkungen.
### SageMaker Deep-Learning-Laufzeit von AI Neo
Sie können die SageMaker AI Neo Deep Learning-Laufzeit verwenden, um Inferenzen mit optimierten Modellen für maschinelles Lernen auf Ihren AWS IoT Greengrass Geräten durchzuführen. Diese Modelle werden mithilfe des SageMaker AI Neo Deep-Learning-Compilers optimiert, um die Geschwindigkeit der Vorhersage von Inferenzen beim maschinellen Lernen zu verbessern. Weitere Informationen zur Modelloptimierung in SageMaker KI finden Sie in der [SageMaker AI Neo-Dokumentation](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
**Anmerkung**
Derzeit können Sie Modelle für maschinelles Lernen mit dem Neo Deep Learning-Compiler nur in bestimmten Amazon Web Services Services-Regionen optimieren. Sie können jedoch die Neo-Deep-Learning-Laufzeit mit optimierten Modellen in allen Modellen verwenden, in AWS-Region denen der AWS IoT Greengrass Kern unterstützt wird. Weitere Informationen finden Sie unter [So konfigurieren Sie Optimized Machine Learning-Inferenz](ml-dlc-console.md).
### MXNet Versionierung
Apache gewährleistet derzeit MXNet keine Aufwärtskompatibilität, sodass Modelle, die Sie mit späteren Versionen des Frameworks trainieren, in früheren Versionen des Frameworks möglicherweise nicht richtig funktionieren. Verwenden Sie in beiden Phasen dieselbe MXNet Framework-Version, um Konflikte zwischen den Phasen Modelltraining und Modellbereitstellung zu vermeiden und ein einheitliches end-to-end Benutzererlebnis zu gewährleisten.
### MXNet auf Raspberry Pi
Greengrass Lambda-Funktionen, die auf lokale MXNet Modelle zugreifen, müssen die folgende Umgebungsvariable setzen:
```
MXNET_ENGINE_TYPE=NativeEngine
```
Sie können die Umgebungsvariable im Funktionscode festlegen oder zur gruppenspezifischen Konfiguration der Funktion hinzufügen. Ein Bespiel, bei dem dieses im Rahmen der Konfigurationseinstellung hinzugefügt wird, finden Sie in diesem [Schritt](ml-console.md#ml-console-config-lambda).
**Anmerkung**
Für die allgemeine Verwendung des MXNet Frameworks, z. B. die Ausführung eines Codebeispiels eines Drittanbieters, muss die Umgebungsvariable auf dem Raspberry Pi konfiguriert werden.
### TensorFlow Einschränkungen bei der Modellverwaltung auf dem Raspberry Pi
Die folgenden Empfehlungen zur Verbesserung der Inferenzergebnisse basieren auf unseren Tests mit den TensorFlow 32-Bit-ARM-Bibliotheken auf der Raspberry Pi-Plattform. Diese Empfehlungen sind für erfahrene Benutzer nur zur Referenz ohne Gewährleistung jedweder Art bestimmt.
+ Modelle, die mit dem [Checkpoint](https://www.tensorflow.org/guide/checkpoint)-Format geschult werden, sollten vor der Bereitstellung im Protokollpufferformat "eingefroren" werden. Ein Beispiel finden Sie in der [Modellbibliothek zur Bildklassifizierung TensorFlow -Slim](https://github.com/tensorflow/models/tree/master/research/slim).
+ Verwenden Sie die TF-Estimator- und TF-Slim-Bibliotheken nicht in Schulungen oder Inferenzcodes. Stattdessen verwenden Sie das Modellbereitstellungsmuster der `.pb`-Datei wie im folgenden Beispiel gezeigt.
```
graph = tf.Graph()
graph_def = tf.GraphDef()
graph_def.ParseFromString(pb_file.read())
with graph.as_default():
tf.import_graph_def(graph_def)
```
**Anmerkung**
Weitere Informationen zu den unterstützten Plattformen für TensorFlow finden Sie TensorFlow in der TensorFlow Dokumentation unter [Installation](https://www.tensorflow.org/install/#installing_from_sources).
# Greifen Sie über Lambda-Funktionen auf Ressourcen für maschinelles Lernen zu
Benutzerdefinierte Lambda-Funktionen können auf Ressourcen für maschinelles Lernen zugreifen, um lokale Inferenzen auf dem Kern auszuführen. AWS IoT Greengrass Eine Machine Learning-Ressource besteht aus dem trainierten Modell und anderen Artefakten, die auf das Core-Gerät heruntergeladen werden.
Damit eine Lambda-Funktion auf eine maschinelle Lernressource auf dem Core zugreifen kann, müssen Sie die Ressource an die Lambda-Funktion anhängen und Zugriffsberechtigungen definieren. Der [Containerisierungsmodus](lambda-group-config.md#lambda-function-containerization) der verbundenen (oder *angehängten*) Lambda-Funktion bestimmt, wie Sie dies tun.
## Zugriffsberechtigungen für Machine Learning-Ressourcen
Ab AWS IoT Greengrass Core v1.10.0 können Sie einen Ressourcenbesitzer für eine maschinelle Lernressource definieren. Der Ressourcenbesitzer steht für die Betriebssystemgruppe und die Berechtigungen, die zum Herunterladen der Ressourcenartefakte AWS IoT Greengrass verwendet werden. Wenn ein Ressourcenbesitzer nicht definiert ist, sind die heruntergeladenen Ressourcenartefakte nur für Root zugänglich.
+ Wenn Lambda-Funktionen, die nicht containerisiert sind, auf eine Ressource für maschinelles Lernen zugreifen, müssen Sie einen Ressourcenbesitzer definieren, da es keine Berechtigungssteuerung durch den Container gibt. Lambda-Funktionen, die nicht containerisiert sind, können die Berechtigungen des Ressourcenbesitzers erben und sie für den Zugriff auf die Ressource verwenden.
+ Wenn nur containerisierte Lambda-Funktionen auf die Ressource zugreifen, empfehlen wir, dass Sie Berechtigungen auf Funktionsebene verwenden, anstatt einen Ressourcenbesitzer zu definieren.
### Eigenschaften der Ressourcenbesitzer
Ein Ressourcenbesitzer gibt einen Gruppenbesitzer und Gruppenbesitzer-Berechtigungen an.
**Gruppenbesitzer**. Die ID der Gruppe (GID) einer vorhandenen Linux-Betriebssystemgruppe auf dem Core-Gerät. Die Berechtigungen der Gruppe werden dem Lambda-Prozess hinzugefügt. Insbesondere wird die GID zur ergänzenden Gruppe IDs der Lambda-Funktion hinzugefügt.
Wenn eine Lambda-Funktion in der Greengrass-Gruppe so konfiguriert ist, dass sie in derselben Betriebssystemgruppe [wie der Ressourcenbesitzer für eine maschinelle Lernressource ausgeführt](lambda-group-config.md#lambda-access-identity) wird, muss die Ressource an die Lambda-Funktion angehängt werden. Andernfalls schlägt die Bereitstellung fehl, da diese Konfiguration implizite Berechtigungen gewährt, mit denen die Lambda-Funktion ohne AWS IoT Greengrass Autorisierung auf die Ressource zugreifen kann. Die Überprüfung der Bereitstellungsvalidierung wird übersprungen, wenn die Lambda-Funktion als Root (UID=0) ausgeführt wird.
Wir empfehlen, dass Sie eine Betriebssystemgruppe verwenden, die nicht von anderen Ressourcen, Lambda-Funktionen oder Dateien auf dem Greengrass-Kern verwendet wird. Durch die Verwendung einer gemeinsam genutzten Betriebssystemgruppe erhalten angehängte Lambda-Funktionen mehr Zugriffsberechtigungen, als sie benötigen. Wenn Sie eine gemeinsam genutzte Betriebssystemgruppe verwenden, muss eine angefügte Lambda-Funktion auch an alle Ressourcen für maschinelles Lernen angehängt werden, die die gemeinsam genutzte Betriebssystemgruppe verwenden. Andernfalls schlägt die Bereitstellung fehl.
**Gruppenbesitzer-Berechtigungen**. Die Nur-Lese- oder Lese- und Schreibberechtigung, die zum Lambda-Prozess hinzugefügt werden soll.
Nicht containerisierte Lambda-Funktionen müssen diese Zugriffsberechtigungen für die Ressource erben. Containerisierte Lambda-Funktionen können diese Berechtigungen auf Ressourcenebene erben oder Berechtigungen auf Funktionsebene definieren. Wenn sie Berechtigungen auf Funktionsebene definieren, müssen die Berechtigungen dieselben oder restriktiver sein als die Berechtigungen auf Ressourcenebene.
Die folgende Tabelle zeigt unterstützte Zugriffsberechtigungskonfigurationen.
------
#### [ GGC v1.10 or later ]
| Eigenschaft | Wenn nur containerisierte Lambda-Funktionen auf die Ressource zugreifen | Wenn nicht containerisierte Lambda-Funktionen auf die Ressource zugreifen |
| --- |--- |--- |
| **Eigenschaften auf Funktionsebene** |
| --- |
| Berechtigungen (Lesen/Schreiben) | Erforderlich, es sei denn, die Ressource definiert einen Ressourcenbesitzer. Wenn ein Ressourcenbesitzer definiert ist, müssen Berechtigungen auf Funktionsebene dieselben oder restriktiver sein als die Ressourcenbesitzer-Berechtigungen. Wenn nur containerisierte Lambda-Funktionen auf die Ressource zugreifen, empfehlen wir, keinen Ressourcenbesitzer zu definieren. | **Nicht containerisierte Lambda-Funktionen:** Nicht unterstützt Lambda-Funktionen, die nicht containerisiert sind, müssen Berechtigungen auf Ressourcenebene erben. **Containerisierte Lambda-Funktionen:** Optional, müssen jedoch dieselben oder restriktiver sein als Berechtigungen auf Ressourcenebene. |
| **Eigenschaften auf Ressourcenebene** |
| --- |
| Ressourcenbesitzer | Optional (nicht empfohlen). | Erforderlich |
| Berechtigungen (Lesen/Schreiben) | Optional (nicht empfohlen). | Erforderlich |
------
#### [ GGC v1.9 or earlier ]
| Eigenschaft | Wenn nur containerisierte Lambda-Funktionen auf die Ressource zugreifen | Wenn nicht containerisierte Lambda-Funktionen auf die Ressource zugreifen |
| --- |--- |--- |
| **Eigenschaften auf Funktionsebene** |
| --- |
| Berechtigungen (Lesen/Schreiben) | Erforderlich | Nicht unterstützt |
| **Eigenschaften auf Ressourcenebene** |
| --- |
| Ressourcenbesitzer | Nicht unterstützt | Nicht unterstützt |
| Berechtigungen (Lesen/Schreiben) | Nicht unterstützt | Nicht unterstützt |
------
**Anmerkung**
Wenn Sie die AWS IoT Greengrass API verwenden, um Lambda-Funktionen und -Ressourcen zu konfigurieren, ist auch die `ResourceId` Eigenschaft auf Funktionsebene erforderlich. Die `ResourceId` Eigenschaft ordnet die Ressource für maschinelles Lernen der Lambda-Funktion zu.
## Zugriffsberechtigungen für Lambda-Funktionen definieren (Konsole)
In der AWS IoT Konsole definieren Sie Zugriffsberechtigungen, wenn Sie eine Machine Learning-Ressource konfigurieren oder eine Ressource an eine Lambda-Funktion anhängen.
**Containerisierte Lambda-Funktionen**
Wenn nur containerisierte Lambda-Funktionen an die Ressource für maschinelles Lernen angehängt sind:
+ Wählen Sie **Keine Systemgruppe** als Ressourcenbesitzer für die maschinelle Lernressource aus. Dies ist die empfohlene Einstellung, wenn nur containerisierte Lambda-Funktionen auf die Ressource für maschinelles Lernen zugreifen. Andernfalls könnten Sie angehängten Lambda-Funktionen mehr Zugriffsberechtigungen erteilen, als sie benötigen.
**Lambda-Funktionen ohne Container** (erfordert GGC v1.10 oder höher)
Wenn Lambda-Funktionen, die nicht containerisiert sind, an die Ressource für maschinelles Lernen angehängt sind:
+ Geben Sie die **Systemgruppen-ID (GID)** an, die als Ressourcenbesitzer für die maschinelle Lernressource verwendet werden soll. Wählen Sie **Systemgruppe und Berechtigungen angeben und** geben Sie die GID ein. Sie können den `getent group` Befehl auf Ihrem Core-Gerät verwenden, um die ID einer Systemgruppe nachzuschlagen.
+ Wählen Sie **Nur-Lese-Zugriff** oder **Lese- und Schreibzugriff** für die **Systemgruppenberechtigungen**.
## Definition von Zugriffsberechtigungen für Lambda-Funktionen (API)
In der AWS IoT Greengrass API definieren Sie Berechtigungen für maschinelles Lernen in der `ResourceAccessPolicy` Eigenschaft für die Lambda-Funktion oder der `OwnerSetting` Eigenschaft für die Ressource.
**Containerisierte Lambda-Funktionen**
Wenn nur containerisierte Lambda-Funktionen an die Ressource für maschinelles Lernen angehängt sind:
+ Definieren Sie für containerisierte Lambda-Funktionen Zugriffsberechtigungen in der `Permission` Eigenschaft der Eigenschaft. `ResourceAccessPolicies` Beispiel:
```
"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
}
}
]
```
+ Bei Machine Learning-Ressourcen lassen Sie die `OwnerSetting`-Eigenschaft weg. Beispiel:
```
"Resources": [
{
"Id": "my-resource-id",
"Name": "my-resource-name",
"ResourceDataContainer": {
"S3MachineLearningModelResourceData": {
"DestinationPath": "/local-destination-path",
"S3Uri": "s3://uri-to-resource-package"
}
}
}
]
```
Dies ist die empfohlene Konfiguration, wenn nur containerisierte Lambda-Funktionen auf die Ressource für maschinelles Lernen zugreifen. Andernfalls könnten Sie angehängten Lambda-Funktionen mehr Zugriffsberechtigungen erteilen, als sie benötigen.
**Lambda-Funktionen ohne Container** (erfordert GGC v1.10 oder höher)
Wenn Lambda-Funktionen, die nicht containerisiert sind, an die Ressource für maschinelles Lernen angehängt sind:
+ Lassen Sie bei Lambda-Funktionen, die nicht containerisiert sind, die Eigenschaft in weg. `Permission` `ResourceAccessPolicies` Diese Konfiguration ist erforderlich und ermöglicht es der Funktion, die Berechtigung auf Ressourcenebene zu erben. Beispiel:
```
"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
}
}
]
```
+ Lassen Sie bei containerisierten Lambda-Funktionen, die auch auf die Ressource für maschinelles Lernen zugreifen, die `Permission` Eigenschaft weg `ResourceAccessPolicies` oder definieren Sie eine Berechtigung, die mit der Berechtigung auf Ressourcenebene identisch oder restriktiver ist. Beispiel:
```
"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
}
}
]
```
+ Definieren Sie für Machine Learning-Ressourcen die `OwnerSetting`-Eigenschaft, einschließlich der untergeordneten `GroupOwner`- und `GroupPermission`-Eigenschaften. Beispiel:
```
"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"
}
}
}
}
]
```
## Zugreifen auf Ressourcen für maschinelles Lernen über den Lambda-Funktionscode
Benutzerdefinierte Lambda-Funktionen verwenden plattformspezifische Betriebssystemschnittstellen, um auf Ressourcen für maschinelles Lernen auf einem Kerngerät zuzugreifen.
------
#### [ GGC v1.10 or later ]
Bei containerisierten Lambda-Funktionen wird die Ressource im Greengrass-Container bereitgestellt und ist auf dem für die Ressource definierten lokalen Zielpfad verfügbar. Bei nicht containerisierten Lambda-Funktionen wird die Ressource mit einem Lambda-spezifischen Arbeitsverzeichnis verknüpft und an die Umgebungsvariable im Lambda-Prozess übergeben. `AWS_GG_RESOURCE_PREFIX`
Um den Pfad zu den heruntergeladenen Artefakten einer maschinellen Lernressource abzurufen, hängen Lambda-Funktionen die `AWS_GG_RESOURCE_PREFIX` Umgebungsvariable an den für die Ressource definierten lokalen Zielpfad an. Für containerisierte Lambda-Funktionen ist der zurückgegebene Wert ein einzelner Schrägstrich (). `/`
```
resourcePath = os.getenv("AWS_GG_RESOURCE_PREFIX") + "/destination-path"
with open(resourcePath, 'r') as f:
# load_model(f)
```
------
#### [ GGC v1.9 or earlier ]
Die heruntergeladenen Artefakte einer Machine Learning-Ressource befinden sich im lokalen Zielpfad, der für die Ressource definiert ist. Nur containerisierte Lambda-Funktionen können in AWS IoT Greengrass Core v1.9 und früheren Versionen auf Ressourcen für maschinelles Lernen zugreifen.
```
resourcePath = "/local-destination-path"
with open(resourcePath, 'r') as f:
# load_model(f)
```
------
Ihre Modellladeimplementierung hängt von Ihrer ML-Bibliothek ab.
## Fehlerbehebung
Verwenden Sie die folgenden Informationen, um Probleme beim Zugriff auf Machine Learning-Ressourcen zu beheben.
**Topics**
+ [Ungültiger MLModel Besitzer — GroupOwnerSetting ist in der ML-Modellressource angegeben, aber GroupOwner oder ist nicht vorhanden GroupPermission](#nocontainer-lambda-invalid-ml-model-owner)
+ [NoContainer Die Funktion kann beim Anhängen von Ressourcen für Machine Learning keine Berechtigungen konfigurieren. bezieht sich auf eine Ressource für maschinelles Lernen mit der entsprechenden Berechtigung in der Ressourcenzugriffsrichtlinie.](#nocontainer-lambda-invalid-resource-access-policy)
+ [Die Funktion bezieht sich auf Machine Learning Learning-Ressource, für die ResourceAccessPolicy sowohl die Berechtigungen als auch die Ressource fehlen OwnerSetting.](#nocontainer-lambda-missing-access-permission)
+ [Die Funktion bezieht sich auf die Machine Learning Learning-Ressource mit der Berechtigung\$1 "rw\$1“, während die Einstellung für den Ressourcenbesitzer GroupPermission nur\$1 "ro\$1“ zulässt.](#container-lambda-invalid-rw-permissions)
+ [NoContainer Die Funktion bezieht sich auf Ressourcen des verschachtelten Zielpfads.](#nocontainer-lambda-nested-destination-path)
+ [Lambda erhält Zugriff auf die Ressource , indem dieselbe Gruppenbesitzer-ID freigegeben wird](#lambda-runas-and-resource-owner)
### Ungültiger MLModel Besitzer — GroupOwnerSetting ist in der ML-Modellressource angegeben, aber GroupOwner oder ist nicht vorhanden GroupPermission
**Lösung:** Dieser Fehler wird angezeigt, wenn eine maschinelle Lernressource das [ResourceDownloadOwnerSetting](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resourcedownloadownersetting.html)Objekt enthält, die erforderliche `GroupPermission` Eigenschaft `GroupOwner` oder aber nicht definiert ist. Um dieses Problem zu beheben, definieren Sie die fehlende Eigenschaft.
### NoContainer Die Funktion kann beim Anhängen von Ressourcen für Machine Learning keine Berechtigungen konfigurieren. bezieht sich auf eine Ressource für maschinelles Lernen mit der entsprechenden Berechtigung in der Ressourcenzugriffsrichtlinie.
**Lösung:** Sie erhalten diesen Fehler, wenn eine nicht containerisierte Lambda-Funktion Berechtigungen auf Funktionsebene für eine maschinelle Lernressource festlegt. Nicht containerisierte Funktionen müssen Berechtigungen von den Ressourcenbesitzer-Berechtigungen erben, die für die Machine Learning-Ressource definiert sind. Um dieses Problem zu beheben, können Sie die [Berechtigungen des Ressourcenbesitzers (Konsole) erben](#non-container-config-console) oder [die Berechtigungen aus der Ressourcenzugriffsrichtlinie (API) der Lambda-Funktion entfernen](#non-container-config-api).
### Die Funktion bezieht sich auf Machine Learning Learning-Ressource, für die ResourceAccessPolicy sowohl die Berechtigungen als auch die Ressource fehlen OwnerSetting.
**Lösung:** Sie erhalten diesen Fehler, wenn die Berechtigungen für die maschinelle Lernressource nicht für die angehängte Lambda-Funktion oder die Ressource konfiguriert sind. Um dieses Problem zu beheben, konfigurieren Sie Berechtigungen in der [ResourceAccessPolicy](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resourceaccesspolicy.html)Eigenschaft für die Lambda-Funktion oder der [OwnerSetting](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-ownersetting.html)Eigenschaft für die Ressource.
### Die Funktion bezieht sich auf die Machine Learning Learning-Ressource mit der Berechtigung\$1 "rw\$1“, während die Einstellung für den Ressourcenbesitzer GroupPermission nur\$1 "ro\$1“ zulässt.
**Lösung:** Sie erhalten diesen Fehler, wenn die für die angehängte Lambda-Funktion definierten Zugriffsberechtigungen die für die maschinelle Lernressource definierten Berechtigungen des Ressourcenbesitzers überschreiten. Um dieses Problem zu beheben, legen Sie restriktivere Berechtigungen für die Lambda-Funktion oder weniger restriktive Berechtigungen für den Ressourcenbesitzer fest.
### NoContainer Die Funktion bezieht sich auf Ressourcen des verschachtelten Zielpfads.
**Lösung:** Sie erhalten diesen Fehler, wenn mehrere maschinelle Lernressourcen, die an eine nicht containerisierte Lambda-Funktion angehängt sind, denselben Zielpfad oder einen verschachtelten Zielpfad verwenden. Um dieses Problem zu beheben, geben Sie separate Zielpfade für die Ressourcen an.
### Lambda erhält Zugriff auf die Ressource , indem dieselbe Gruppenbesitzer-ID freigegeben wird
**Lösung:** Sie erhalten diesen Fehler, `runtime.log` wenn dieselbe Betriebssystemgruppe als [Run as Identity der Lambda-Funktion und als](lambda-group-config.md#lambda-access-identity) [Ressourcenbesitzer für eine Machine Learning-Ressource](#ml-resource-owner) angegeben ist, die Ressource jedoch nicht an die Lambda-Funktion angehängt ist. Diese Konfiguration gewährt der Lambda-Funktion implizite Berechtigungen, mit denen sie ohne AWS IoT Greengrass Autorisierung auf die Ressource zugreifen kann.
Um dieses Problem zu beheben, verwenden Sie eine andere Betriebssystemgruppe für eine der Eigenschaften oder hängen Sie die Ressource für maschinelles Lernen an die Lambda-Funktion an.
## Weitere Informationen finden Sie auch unter
+ [Durchführen von Machine Learning-Inferenzen](ml-inference.md)
+ [So konfigurieren Sie die Inferenz für maschinelles Lernen mit dem AWS-Managementkonsole](ml-console.md)
+ [So konfigurieren Sie eine optimierte Inferenz für maschinelles Lernen mit dem AWS-Managementkonsole](ml-dlc-console.md)
+ [AWS IoT Greengrass Version 1 API Reference](https://docs.aws.amazon.com/greengrass/v1/apireference/api-doc.html)
# So konfigurieren Sie die Inferenz für maschinelles Lernen mit dem AWS-Managementkonsole
Um die Schritte in diesem Tutorial ausführen zu können, benötigen Sie AWS IoT Greengrass Core v1.10 oder höher.
Sie können Machine Learning (ML)-Inferenz lokal auf einem Greengrass Core-Gerät mit lokal generierten Daten durchführen. Weitere Informationen einschließlich Anforderungen und Einschränkungen finden Sie unter [Durchführen von Machine Learning-Inferenzen](ml-inference.md).
In diesem Tutorial wird beschrieben, wie Sie mithilfe der AWS-Managementkonsole eine Greengrass-Gruppe konfigurieren, um eine Lambda-Inferenz-App auszuführen, die Bilder von einer Kamera lokal erkennt, ohne Daten an die Cloud zu senden. Die Inferenz-App greift auf das Kameramodul auf einem Raspberry Pi zu und führt die Inferenz mithilfe des Open-Source-Modells aus. [SqueezeNet](https://github.com/DeepScale/SqueezeNet)
Das Tutorial enthält die folgenden allgemeinen Schritte:
1. [Konfigurieren des Raspberry Pi](#config-raspberry-pi)
1. [Installieren Sie das MXNet Framework](#install-mxnet)
1. [Erstellen eines Modellpakets](#package-ml-model)
1. [Eine Lambda-Funktion erstellen und veröffentlichen](#ml-console-create-lambda)
1. [Fügen Sie die Lambda-Funktion zur Gruppe hinzu](#ml-console-config-lambda)
1. [Hinzufügen von Ressourcen zur Gruppe](#ml-console-add-resources)
1. [Hinzufügen eines Abonnements zur Gruppe](#ml-console-add-subscription)
1. [Bereitstellen der Gruppe](#ml-console-deploy-group)
1. [Testen der Anwendung](#ml-console-test-app)
## Voraussetzungen
Zum Durchführen dieses Tutorials benötigen Sie Folgendes:
+ Raspberry Pi 4 Modell B oder Raspberry Pi 3 Modell B/B\$1, eingerichtet und konfiguriert für die Verwendung mit. AWS IoT Greengrass Um Ihren Raspberry Pi mit AWS IoT Greengrass einzurichten, führen Sie das [Greengrass Device Setup-Skript](quick-start.md) aus oder stellen Sie sicher, dass Sie [Modul 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) und [Modul 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) von [Erste Schritte mit AWS IoT Greengrass](gg-gs.md) abgeschlossen haben.
**Anmerkung**
Der Raspberry Pi benötigt möglicherweise eine [2,5-A-Stromversorgung](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/), um die Deep-Learning-Frameworks auszuführen, die normalerweise für die Bildklassifizierung verwendet werden. Ein Netzteil mit einer niedrigeren Nennleistung kann dazu führen, dass das Gerät neu gestartet wird.
+ [Raspberry Pi Kameramodul V2 – 8 Megapixel, 1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Informationen zur Einrichtung der Kamera finden Sie in der Dokumentation zum Raspberry Pi unter [Anschließen der Kamera](https://www.raspberrypi.org/documentation/usage/camera/).
+ Eine Greengrass-Gruppe und ein Greengrass Core. Informationen zum Erstellen einer Greengrass-Gruppe oder eines Greengrass-Kerns finden Sie unter[Erste Schritte mit AWS IoT Greengrass](gg-gs.md).
**Anmerkung**
Dieses Tutorial verwendet einen Raspberry Pi, AWS IoT Greengrass unterstützt aber auch andere Plattformen wie [Intel Atom](#atom-lambda-config) und [NVIDIA TX2 Jetson](#jetson-lambda-config). Im Beispiel für Jetson können Sie statische Bilder anstelle von Bildern verwenden TX2, die von einer Kamera gestreamt wurden. Wenn Sie das TX2 Jetson-Beispiel verwenden, müssen Sie möglicherweise Python 3.6 anstelle von Python 3.7 installieren. Informationen zur Konfiguration Ihres Geräts für die Installation der AWS IoT Greengrass Core-Software finden Sie unter[Einrichten anderer Geräte](setup-filter.other.md).
Für Plattformen von Drittanbietern, die AWS IoT Greengrass dies nicht unterstützen, müssen Sie Ihre Lambda-Funktion im Modus ohne Container ausführen. Um im Modus ohne Container ausgeführt zu werden, müssen Sie Ihre Lambda-Funktion als Root ausführen. Weitere Informationen erhalten Sie unter [Überlegungen bei der Wahl der Containerisierung von Lambda-Funktionen](lambda-group-config.md#lambda-containerization-considerations) und [Einstellung der Standardzugriffsidentität für Lambda-Funktionen in einer Gruppe](lambda-group-config.md#lambda-access-identity-groupsettings).
## Schritt 1: Konfigurieren des Raspberry Pi
In diesem Schritt installieren Sie Updates für das Raspbian-Betriebssystem, installieren die Kameramodulsoftware und Python-Abhängigkeiten und aktivieren die Kameraschnittstelle.
Führen Sie im Raspberry Pi-Terminal die folgenden Befehle aus.
1. Installieren von Updates für Raspbian.
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. Installieren Sie die `picamera`-Schnittstelle für das Kameramodul und andere Python-Bibliotheken, die für dieses Tutorial erforderlich sind.
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
Überprüfen Sie die Installation:
+ Stellen Sie sicher, dass Ihre Python 3.7-Installation pip enthält.
```
python3 -m pip
```
Wenn pip nicht installiert ist, laden Sie es von der [pip-Website](https://pip.pypa.io/en/stable/installing/) herunter und führen Sie dann den folgenden Befehl aus.
```
python3 get-pip.py
```
+ Stellen Sie sicher, dass Ihre Python-Version 3.7 oder höher ist.
```
python3 --version
```
Wenn in der Ausgabe eine frühere Version aufgelistet ist, führen Sie den folgenden Befehl aus.
```
sudo apt-get install -y python3.7-dev
```
+ Stellen Sie sicher, dass Setuptools und Picamera erfolgreich installiert wurden.
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Wenn die Ausgabe keine Fehler enthält, ist die Überprüfung erfolgreich.
**Anmerkung**
Wenn die auf Ihrem Gerät installierte ausführbare Python-Datei `python3.7` ist, verwenden Sie `python3.7` anstelle von `python3` für die Befehle in diesem Tutorial. Stellen Sie sicher, dass Ihre pip-Installation der richtigen `python3.7`- oder `python3`-Version zugeordnet ist, um Abhängigkeitsfehler zu vermeiden.
1. Starten Sie den Raspberry Pi neu.
```
sudo reboot
```
1. Öffnen Sie das Raspberry Pi-Konfigurations-Tool.
```
sudo raspi-config
```
1. Verwenden Sie die Pfeiltasten zum Öffnen von **Interfacing Options** (Verbindungsoptionen) und aktivieren Sie die Kameraschnittstelle. Wenn Sie dazu aufgefordert werden, lassen Sie den Neustart des Geräts zu.
1. Geben Sie den folgenden Befehl ein, um die Einrichtung der Kamera zu testen.
```
raspistill -v -o test.jpg
```
So werden ein Vorschaufenster im Raspberry Pi geöffnet, ein Bild mit dem Namen `test.jpg` in Ihrem aktuellen Verzeichnis gespeichert und Informationen über die Kamera im Raspberry Pi-Terminal angezeigt.
## Schritt 2: Installieren Sie das Framework MXNet
Installieren Sie in diesem Schritt MXNet Bibliotheken auf Ihrem Raspberry Pi.
1. Melden Sie sich per Fernzugriff bei Ihrem Raspberry Pi an.
```
ssh pi@your-device-ip-address
```
1. Öffnen Sie die MXNet Dokumentation, öffnen Sie [Installation MXNet](https://mxnet.apache.org/get_started/?) und folgen Sie den Anweisungen zur Installation MXNet auf dem Gerät.
**Anmerkung**
Wir empfehlen, Version 1.5.0 zu installieren und MXNet aus dem Quellcode für dieses Tutorial zu bauen, um Gerätekonflikte zu vermeiden.
1. Überprüfen Sie nach der Installation MXNet die folgende Konfiguration:
+ Stellen Sie sicher, dass das `ggc_user` Systemkonto das MXNet Framework verwenden kann.
```
sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
+ Stellen Sie sicher, dass NumPy es installiert ist.
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## Schritt 3: Erstellen Sie ein MXNet Modellpaket
In diesem Schritt erstellen Sie ein Modellpaket, das ein vortrainiertes MXNet Mustermodell enthält, das auf Amazon Simple Storage Service (Amazon S3) hochgeladen werden soll. AWS IoT Greengrass kann ein Modellpaket von Amazon S3 verwenden, sofern Sie das Format tar.gz oder zip verwenden.
1. Laden Sie auf Ihrem Computer das MXNet Beispiel für Raspberry Pi von herunter[Beispiele für Machine Learning](what-is-gg.md#gg-ml-samples).
1. Entpacken Sie die heruntergeladene `mxnet-py3-armv7l.tar.gz`-Datei.
1. Navigieren Sie zum `squeezenet` Verzeichnis .
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/models/squeezenet
```
Die `squeezenet.zip`-Datei in diesem Verzeichnis ist Ihr Modellpaket. Es enthält SqueezeNet Open-Source-Modellartefakte für ein Bildklassifizierungsmodell. Später laden Sie dieses Modellpaket auf Amazon S3 hoch.
## Schritt 4: Eine Lambda-Funktion erstellen und veröffentlichen
In diesem Schritt erstellen Sie ein Lambda-Funktions-Bereitstellungspaket und eine Lambda-Funktion. Veröffentlichen Sie anschließend eine Funktionsversion und erstellen einen Alias.
Erstellen Sie zunächst das Lambda-Funktionsbereitstellungspaket.
1. Navigieren Sie auf Ihrem Computer zum `examples`-Verzeichnis im Beispielpaket, das Sie in [Schritt 3: Erstellen Sie ein MXNet Modellpaket](#package-ml-model) entpackt haben.
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/examples
```
Das `examples`-Verzeichnis enthält Funktionscode und Abhängigkeiten.
+ `greengrassObjectClassification.py` ist der in diesem Tutorial verwendete Inferenzcode. Sie können diesen Code als Vorlage verwenden, um eine eigene Inferenzfunktion zu erstellen.
+ `greengrasssdk`ist Version 1.5.0 des AWS IoT Greengrass Core SDK für Python.
**Anmerkung**
Wenn eine neue Version verfügbar ist, können Sie sie herunterladen und die SDK-Version in Ihrem Bereitstellungspaket aktualisieren. Weitere Informationen finden Sie unter [AWS IoT Greengrass Core SDK for Python](https://github.com/aws/aws-greengrass-core-sdk-python/) on GitHub.
1. Komprimieren Sie den Inhalt des `examples`-Verzeichnisses in eine Datei namens `greengrassObjectClassification.zip`. Dies ist Ihr Bereitstellungspaket.
```
zip -r greengrassObjectClassification.zip .
```
**Anmerkung**
Stellen Sie sicher, dass sich die `.py`-Dateien und -Abhängigkeiten im Stammverzeichnis befinden.
Als Nächstes erstellen Sie die Lambda-Funktion.
1. Wählen Sie in der AWS IoT Konsole **Funktionen** und **Funktion erstellen** aus.
1. Wählen Sie **Author von Grund auf neu** und verwenden Sie die folgenden Werte, um Ihre Funktion zu erstellen:
+ Geben Sie für **Function name** (Funktionsname) **greengrassObjectClassification** ein.
+ Wählen Sie für **Runtime (Laufzeit)** die Option **Python 3.7** aus.
Behalten Sie für **Berechtigungen** die Standardeinstellung bei. Dadurch wird eine Ausführungsrolle erstellt, die grundlegende Lambda-Berechtigungen gewährt. Diese Rolle wird nicht verwendet von AWS IoT Greengrass.
1. Wählen Sie **Funktion erstellen**.
Laden Sie jetzt Ihr Lambda-Funktionsbereitstellungspaket hoch und registrieren Sie den Handler.
1. Wählen Sie Ihre Lambda-Funktion und laden Sie Ihr Lambda-Funktionspaket hoch.
1. Wählen Sie auf der Registerkarte **Code** unter **Codequelle** die Option **Hochladen** von aus. Wählen Sie in der Dropdownliste die **ZIP-Datei** aus.
![\[Das Drop-down-Menü „Von hochladen“, wobei die ZIP-Datei hervorgehoben ist.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. Wählen Sie **Hochladen** und dann Ihr `greengrassObjectClassification.zip` Bereitstellungspaket aus. Wählen Sie dann **Save (Speichern)** aus.
1. Wählen Sie auf der Registerkarte **Code** für die Funktion unter **Laufzeiteinstellungen** die Option **Bearbeiten** aus, und geben Sie dann die folgenden Werte ein.
+ Wählen Sie für **Runtime (Laufzeit)** die Option **Python 3.7** aus.
+ Geben Sie unter **Handler** **greengrassObjectClassification.function\$1handler** ein.
Wählen Sie **Speichern**.
Veröffentlichen Sie als Nächstes die erste Version Ihrer Lambda-Funktion. Anschließend erstellen Sie einen [Alias für die Version](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html).
**Anmerkung**
Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nach Version referenzieren. Die Verwendung eines Alias erleichtert die Verwaltung von Codeaktualisierungen, da Sie Ihre Abonnementtabelle oder Gruppendefinition nicht ändern müssen, wenn der Funktionscode aktualisiert wird. Stattdessen verweisen Sie einfach mit dem Alias auf die neue Funktionsversion.
1. Wählen Sie im Menü **Actions** die Option **Publish new version** aus.
![\[Menü „Actions“ mit der Option „Publish new version“.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/ml-inference/lambda-publish-version.png)
1. Geben Sie unter **Version description (Versionsbeschreibung)** den Wert **First version** ein und wählen Sie dann **Publish (Veröffentlichen)** aus.
1. Wählen Sie auf der Konfigurationsseite **greengrassObjectClassification: 1** im Menü **Aktionen** die Option **Alias erstellen** aus.
![\[Menü „Actions“ mit der Option „Create alias“\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/ml-inference/lambda-create-alias.png)
1. Geben Sie auf der Seite **Create a new alias** folgende Werte an:
+ Geben Sie unter **Name** **mlTest** ein.
+ Geben Sie in **Version (Version)** **1** ein.
**Anmerkung**
AWS IoT Greengrass unterstützt keine Lambda-Aliase für **\$1LATEST-Versionen**.
1. Wählen Sie **Speichern**.
Fügen Sie nun die Lambda-Funktion zu Ihrer Greengrass-Gruppe hinzu.
## Schritt 5: Fügen Sie die Lambda-Funktion zur Greengrass-Gruppe hinzu
Fügen Sie in diesem Schritt die Lambda-Funktion zur Gruppe hinzu und konfigurieren Sie dann ihre Lebenszyklus- und Umgebungsvariablen.
Fügen Sie zunächst die Lambda-Funktion zu Ihrer Greengrass-Gruppe hinzu.
1. Erweitern Sie im Navigationsbereich der AWS IoT Konsole unter **Verwalten** die Option **Greengrass-Geräte** und wählen Sie dann **Gruppen (V1)** aus.
1. Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte **Lambda-Funktionen** aus.
1. Wählen Sie im Abschnitt **Meine Lambda-Funktionen** die Option **Hinzufügen** aus.
1. Wählen **greengrassObjectClassification**Sie für die **Lambda-Funktion**.
1. Wählen Sie für die **Lambda-Funktionsversion** **alias:MLTest**.
Als Nächstes konfigurieren Sie den Lebenszyklus und die Umgebungsvariablen der Lambda-Funktion.
1. Nehmen Sie im Abschnitt **Lambda-Funktionskonfiguration** die folgenden Aktualisierungen vor.
**Anmerkung**
Wir empfehlen, dass Sie Ihre Lambda-Funktion ohne Containerisierung ausführen, sofern Ihr Geschäftsszenario dies nicht erfordert. Auf diese Weise können Sie auf die GPU und Kamera Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen. Wenn Sie ohne Containerisierung arbeiten, müssen Sie auch Root-Zugriff auf Ihre AWS IoT Greengrass Lambda-Funktionen gewähren.
1. **Um ohne Containerisierung zu laufen:**
+ Wählen Sie für **Systembenutzer und Gruppe** die Option. **Another user ID/group ID** Geben Sie als **Systembenutzer-ID** ein**0**. Geben Sie als **Systemgruppen-ID** ein**0**.
Dadurch kann Ihre Lambda-Funktion als Root ausgeführt werden. Weitere Hinweise zur Ausführung als Root finden Sie unter[Einstellung der Standardzugriffsidentität für Lambda-Funktionen in einer Gruppe](lambda-group-config.md#lambda-access-identity-groupsettings).
**Tipp**
Sie müssen Ihre `config.json` Datei auch aktualisieren, um Root-Zugriff auf Ihre Lambda-Funktion zu gewähren. Informationen zum Verfahren finden Sie unter[Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root).
+ **Wählen Sie für die **Containerisierung von Lambda-Funktionen** die Option Kein Container aus.**
Weitere Hinweise zur Ausführung ohne Containerisierung finden Sie unter. [Überlegungen bei der Wahl der Containerisierung von Lambda-Funktionen](lambda-group-config.md#lambda-containerization-considerations)
+ Geben Sie in **Timeout (Zeitüberschreitung)** **10 seconds** ein.
+ **Wählen Sie für **Pinned** die Option True aus.**
Weitere Informationen finden Sie unter [Lebenszykluskonfiguration für Greengrass Lambda-Funktionen](lambda-functions.md#lambda-lifecycle).
1. **Um stattdessen im containerisierten Modus zu starten:**
**Anmerkung**
Wir empfehlen nicht, im containerisierten Modus zu arbeiten, es sei denn, Ihr Geschäftsszenario erfordert dies.
+ Wählen Sie für **Systembenutzer und Gruppe** die Option **Gruppenstandard verwenden** aus.
+ Wählen Sie für die **Containerisierung von Lambda-Funktionen** die Option Gruppenstandard **verwenden** aus.
+ Geben Sie in **Memory Limit (Speicherlimit)** **96 MB** ein.
+ Geben Sie in **Timeout (Zeitüberschreitung)** **10 seconds** ein.
+ **Wählen Sie für **Pinned** die Option True aus.**
Weitere Informationen finden Sie unter [Lebenszykluskonfiguration für Greengrass Lambda-Funktionen](lambda-functions.md#lambda-lifecycle).
1. Erstellen Sie in **Environment variables (Umgebungsvariablen)** ein Schlüssel-Wert-Paar. Ein Schlüssel-Wert-Paar ist für Funktionen erforderlich, die mit MXNet Modellen auf einem Raspberry Pi interagieren.
Verwenden Sie als Schlüssel MXNET\$1ENGINE\$1TYPE. Verwenden Sie für den Wert. NaiveEngine
**Anmerkung**
In Ihren eigenen benutzerdefinierten Lambda-Funktionen können Sie optional die Umgebungsvariable in Ihrem Funktionscode festlegen.
1. Behalten Sie die Standardwerte für alle anderen Eigenschaften bei und wählen Sie **Lambda-Funktion hinzufügen**.
## Schritt 6: Hinzufügen von Ressourcen zur Greengrass-Gruppe
Erstellen Sie in diesem Schritt Ressourcen für das Kameramodul und das ML-Inferenzmodell und ordnen Sie die Ressourcen der Lambda-Funktion zu. Dadurch kann die Lambda-Funktion auf die Ressourcen auf dem Kerngerät zugreifen.
**Anmerkung**
Wenn Sie im Modus ohne Container arbeiten, AWS IoT Greengrass können Sie auf die GPU und Kamera Ihres Geräts zugreifen, ohne diese Geräteressourcen zu konfigurieren.
Erstellen Sie zunächst zwei lokale Geräteressourcen für die Kamera: eine für den gemeinsam genutzten Speicher und eine für die Geräteschnittstelle. Weitere Informationen zum Zugriff auf lokale Ressourcen finden Sie unter [Greifen Sie mit Lambda-Funktionen und Konnektoren auf lokale Ressourcen zu](access-local-resources.md).
1. **Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte Ressourcen aus.**
1. Wählen Sie im Abschnitt **Lokale Ressourcen** die Option **Lokale Ressource hinzufügen** aus.
1. Verwenden Sie auf der Seite **Lokale Ressource hinzufügen** die folgenden Werte:
+ Geben Sie für **Resource name (Ressourcenname)** **videoCoreSharedMemory** ein.
+ Wählen Sie in **Resource type (Ressourcentyp)** die Option **Device (Gerät)** aus.
+ Geben Sie für **Lokaler Gerätepfad** den Wert ein**/dev/vcsm**.
Der Gerätepfad ist der lokale absolute Pfad der Geräteressource. Dieser Pfad kann nur auf ein zeichenorientiertes Gerät oder ein Blockgerät unter `/dev` verweisen.
+ Wählen Sie für **Systemgruppenbesitzer und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe, der die Ressource gehört, automatisch hinzufügen** aus.
Mit der Option **Systemgruppenbesitzer und Dateizugriffsberechtigungen** können Sie dem Lambda-Prozess zusätzliche Dateizugriffsberechtigungen gewähren. Weitere Informationen finden Sie unter [Dateizugriffsberechtigung des Gruppenbesitzers](access-local-resources.md#lra-group-owner).
1. Als nächstes fügen Sie eine lokale Geräteressource für die Kameraschnittstelle hinzu.
1. Wählen Sie **Lokale Ressource hinzufügen**.
1. Verwenden Sie auf der Seite **Lokale Ressource hinzufügen** die folgenden Werte:
+ Geben Sie für **Resource name (Ressourcenname)** **videoCoreInterface** ein.
+ Wählen Sie in **Resource type (Ressourcentyp)** die Option **Device (Gerät)** aus.
+ Geben Sie für **Lokaler Gerätepfad** den Wert ein**/dev/vchiq**.
+ Wählen Sie für **Systemgruppenbesitzer und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe, der die Ressource gehört, automatisch hinzufügen** aus.
1. Wählen Sie unten auf der Seite die Option **Ressource hinzufügen** aus.
Fügen Sie nun das Inferenz-Modell als Machine Learning-Ressource hinzu. Dieser Schritt beinhaltet das Hochladen des `squeezenet.zip` Modellpakets auf Amazon S3.
1. Wählen Sie auf der Registerkarte **Ressourcen** für Ihre Gruppe im Abschnitt **Machine Learning** die Option **Ressource für maschinelles Lernen hinzufügen** aus.
1. Geben Sie auf der Seite **Ressource für maschinelles Lernen hinzufügen** als **Ressourcenname** den Text ein**squeezenet\$1model**.
1. Wählen Sie als **Modellquelle** die Option **Ein in S3 gespeichertes Modell verwenden aus, z. B. ein mit dem Deep Learning Compiler optimiertes Modell**.
1. Geben Sie für **S3-URI** einen Pfad ein, in dem der S3-Bucket gespeichert ist.
1. Wählen Sie **S3 durchsuchen**. Dadurch wird ein neuer Tab zur Amazon S3 S3-Konsole geöffnet.
1. Laden Sie die `squeezenet.zip` Datei auf der Registerkarte Amazon S3 S3-Konsole in einen S3-Bucket hoch. Weitere Informationen finden Sie unter [Wie lade ich Dateien und Ordner in einen S3-Bucket hoch?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.
**Anmerkung**
Damit auf den S3-Bucket zugegriffen werden kann, muss Ihr Bucket-Name die Zeichenfolge enthalten **greengrass** und der Bucket muss sich in derselben Region befinden, die Sie für verwenden AWS IoT Greengrass. Wählen Sie einen eindeutigen Namen (wie z. B.: **greengrass-bucket-*user-id*-*epoch-time***). Verwenden Sie keinen Punkt (`.`) im Bucket-Namen.
1. Suchen Sie auf der Registerkarte „ AWS IoT Greengrass Konsole“ Ihren S3-Bucket und wählen Sie ihn aus. Suchen Sie Ihre hochgeladene Datei `squeezenet.zip` und wählen Sie **Select (Auswählen)**. Möglicherweise müssen Sie die **Refresh (Aktualisieren)** wählen, um die Liste der verfügbaren Buckets und Dateien zu aktualisieren.
1. Geben Sie für **Destination path (Zielpfad)** **/greengrass-machine-learning/mxnet/squeezenet** ein.
Dies ist das Ziel für das lokale Modell im Lambda-Laufzeit-Namespace. Wenn Sie die Gruppe bereitstellen, AWS IoT Greengrass ruft das Quellmodellpaket ab und extrahiert dann den Inhalt in das angegebene Verzeichnis. Die Lambda-Beispielfunktion für dieses Tutorial ist bereits für die Verwendung dieses Pfads (in der `model_path` Variablen) konfiguriert.
1. Wählen Sie unter **Systemgruppenbesitzer und Dateizugriffsberechtigungen** die Option **Keine Systemgruppe** aus.
1. Wählen Sie **Add resource (Ressource hinzufügen)** aus.
### Verwenden von SageMaker KI-trainierten Modellen
In diesem Tutorial wird ein Modell verwendet, das in Amazon S3 gespeichert ist, aber Sie können auch problemlos SageMaker KI-Modelle verwenden. Die AWS IoT Greengrass Konsole verfügt über eine integrierte SageMaker KI-Integration, sodass Sie diese Modelle nicht manuell auf Amazon S3 hochladen müssen. Die Anforderungen und Einschränkungen für die Verwendung von SageMaker KI-Modellen finden Sie unter[Unterstützte Modellquellen](ml-inference.md#supported-model-sources).
So verwenden Sie ein SageMaker KI-Modell:
+ Wählen Sie als **Modellquelle** die Option **Ein in AWS SageMaker KI trainiertes Modell verwenden** und wählen Sie dann den Namen des Trainingsjobs des Modells aus.
+ Geben Sie **unter Zielpfad** den Pfad zu dem Verzeichnis ein, in dem Ihre Lambda-Funktion nach dem Modell sucht.
## Schritt 7: Hinzufügen eines Abonnements zur Greengrass-Gruppe
In diesem Schritt fügen Sie der Gruppe ein Abonnement hinzu. Dieses Abonnement ermöglicht es der Lambda-Funktion, Vorhersageergebnisse zu senden, AWS IoT indem sie sie in einem MQTT-Thema veröffentlicht.
1. Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte **Abonnements** und dann Abonnement **hinzufügen** aus.
1. Konfigurieren Sie auf der Seite mit den **Abonnementdetails** die Quelle und das Ziel wie folgt:
1. Wählen Sie **unter Quelltyp** die Option **Lambda-Funktion** und dann aus **greengrassObjectClassification**.
1. Wählen Sie **unter Zieltyp** die Option **Service** und dann **IoT Cloud** aus.
1. Geben Sie **hello/world** im **Themenfilter** den Text ein und wählen Sie dann **Abonnement erstellen** aus.
## Schritt 8: Bereitstellen der Greengrass-Gruppe
In diesem Schritt stellen Sie die aktuelle Version der Gruppendefinition für das Greengrass Core-Gerät bereit. Die Definition enthält die Lambda-Funktion, die Ressourcen und die Abonnementkonfigurationen, die Sie hinzugefügt haben.
1. Stellen Sie sicher, dass der AWS IoT Greengrass Core läuft. Führen Sie im Raspberry Pi-Terminal die folgenden Befehle aus, falls nötig.
1. So prüfen Sie, ob der Daemon ausgeführt wird:
```
ps aux | grep -E 'greengrass.*daemon'
```
Wenn die Ausgabe einen `root`-Eintrag für `/greengrass/ggc/packages/1.11.6/bin/daemon` enthält, dann wird der Daemon ausgeführt.
**Anmerkung**
Die Version im Pfad hängt von der AWS IoT Greengrass Core-Softwareversion ab, die auf Ihrem Core-Gerät installiert ist.
1. Um den Daemon zu starten:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Wählen Sie auf der Seite mit der Gruppenkonfiguration die Option **Deploy** aus.
![\[Die Seite der Gruppe mit hervorgehobenen Optionen „Bereitstellungen“ und „Bereitstellen“.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/console-group-deployments-deploy.png)
1. **Wählen Sie auf der Registerkarte **Lambda-Funktionen** im Abschnitt **System-Lambda-Funktionen** die Option **IP-Detektor** und dann Bearbeiten aus.**
1. Wählen **Sie im Dialogfeld IP-Detektoreinstellungen bearbeiten** die Option **MQTT-Broker-Endpunkte automatisch erkennen und überschreiben** aus.
1. Wählen Sie **Speichern**.
Damit können Geräte automatisch Core-Verbindungsinformationen abrufen, z. B. die IP-Adresse, DNS und die Portnummer. Eine automatische Erkennung wird empfohlen, unterstützt aber AWS IoT Greengrass auch manuell angegebene Endpunkte. Sie werden nur bei der ersten Bereitstellung der Gruppe zur Angabe der Ermittlungsmethode aufgefordert.
**Anmerkung**
Wenn Sie dazu aufgefordert werden, erteilen Sie die Erlaubnis, die [Greengrass-Servicerolle zu erstellen und sie Ihrer AWS-Konto aktuellen AWS-Region Rolle](service-role.md) zuzuordnen. Diese Rolle ermöglicht AWS IoT Greengrass den Zugriff auf Ihre Ressourcen in AWS Diensten.
Auf der Seite **Deployments** werden der Zeitstempel, die Versions-ID und der Status der Bereitstellung angegeben. Nach Abschluss sollte der für die Bereitstellung angezeigte Status **Abgeschlossen** lauten.
Weitere Informationen über Bereitstellungen finden Sie unter [AWS IoT Greengrass Gruppen für einen AWS IoT Greengrass Kern bereitstellen](deployments.md). Hilfe zur Problembehebung finden Sie unter [Problembehebung AWS IoT Greengrass](gg-troubleshooting.md).
## Schritt 9: Testen der Inferenzanwendung
Nun können Sie prüfen, ob die Bereitstellung korrekt konfiguriert ist. Zum Testen abonnieren Sie das `hello/world` Thema und sehen sich die Prognoseergebnisse an, die von der Lambda-Funktion veröffentlicht werden.
**Anmerkung**
Wenn ein Bildschirm mit dem Raspberry Pi verbunden ist, wird das Livebild der Kamera in einem Vorschaufenster angezeigt.
1. Wählen Sie in der AWS IoT Konsole unter **Test** die Option **MQTT-Testclient** aus.
1. Verwenden Sie für **Subscriptions** (Abonnements) die folgenden Werte:
+ Verwenden Sie als Abonnementthema „hello/world“.
+ Wählen Sie unter **Zusätzliche Konfiguration** für die **Anzeige von MQTT-Payloads die Option Payloads** als Zeichenketten **anzeigen** aus.
1. Wählen Sie **Subscribe (Abonnieren)** aus.
Wenn der Test erfolgreich ist, werden die Meldungen der Lambda-Funktion unten auf der Seite angezeigt. Jede Nachricht enthält die ersten fünf der gesamten Prognoseergebnisse des Abbildes im Format: Wahrscheinlichkeit, prognostizierte Klassen-ID und zugehöriger Klassenname.
![\[Die Seite „Subscriptions“ zeigt Testergebnisse mit Nachrichtendaten an.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/ml-inference/prediction-results.png)
### Problembehandlung bei AWS IoT Greengrass ML-Inferenz
Wenn der Test nicht erfolgreich ist, können Sie folgende Schritte ausführen, um den Fehler zu beheben. Führen Sie im Raspberry Pi-Terminal die Befehle aus.
#### Fehlerprotokolle prüfen
1. Wechseln Sie zum Root-Benutzer und navigieren Sie zum Verzeichnis `log`. Für den Zugriff auf AWS IoT Greengrass Protokolle sind Root-Rechte erforderlich.
```
sudo su
cd /greengrass/ggc/var/log
```
1. Überprüfen Sie im `system`-Verzeichnis `runtime.log` oder `python_runtime.log`.
Überprüfen Sie im `user/region/account-id`-Verzeichnis `greengrassObjectClassification.log`.
Weitere Informationen finden Sie unter [Fehlerbehebung mit Protokollen](gg-troubleshooting.md#troubleshooting-logs).
##### Fehler beim Entpacken in "Runtime.log"
Wenn `runtime.log` einen Fehler enthält, der wie folgt aussieht, stellen Sie sicher, dass Ihr `tar.gz`-Quellmodellpaket über ein übergeordnetes Verzeichnis verfügt.
```
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
```
Wenn Ihr Paket über kein übergeordnetes Verzeichnis verfügt, das die Modelldateien enthält, verwenden Sie den folgenden Befehl, um das Modell erneut zu verpacken:
```
tar -zcvf model.tar.gz ./model
```
Beispiel:
```
─$ tar -zcvf test.tar.gz ./test
./test
./test/some.file
./test/some.file2
./test/some.file3
```
**Anmerkung**
Verwenden Sie keine abschließenden `/*`-Zeichen in diesem Befehl.
#### Stellen Sie sicher, dass die Lambda-Funktion erfolgreich bereitgestellt wurde
1. Listet den Inhalt des bereitgestellten Lambda im `/lambda` Verzeichnis auf. Ersetzen Sie die Platzhalterwerte, bevor Sie den Befehl ausführen.
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. Überprüfen Sie, ob das Verzeichnis denselben Inhalt wie das `greengrassObjectClassification.zip`-Bereitstellungspaket enthält, das Sie in [Schritt 4: Eine Lambda-Funktion erstellen und veröffentlichen](#ml-console-create-lambda) hochgeladen haben.
Stellen Sie sicher, dass sich die `.py`-Dateien und -Abhängigkeiten im Stammverzeichnis befinden.
#### Sicherstellen, dass das Inferenzmodell erfolgreich bereitgestellt wird
1. Finden Sie die Prozessidentifikationsnummer (PID) des Lambda-Laufzeitprozesses:
```
ps aux | grep 'lambda-function-name*'
```
In der Ausgabe erscheint die PID in der zweiten Spalte der Zeile für den Lambda-Laufzeitprozess.
1. Geben Sie den Lambda-Runtime-Namespace ein. Achten Sie darauf, den *pid* Platzhalterwert zu ersetzen, bevor Sie den Befehl ausführen.
**Anmerkung**
Dieses Verzeichnis und sein Inhalt befinden sich im Lambda-Runtime-Namespace, sodass sie in einem regulären Linux-Namespace nicht sichtbar sind.
```
sudo nsenter -t pid -m /bin/bash
```
1. Listen Sie den Inhalt des lokalen Verzeichnisses, das Sie für die ML-Ressource angegeben haben, auf.
```
cd /greengrass-machine-learning/mxnet/squeezenet/
ls -ls
```
Die Dateien sollten folgendermaßen aussehen:
```
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
```
## Nächste Schritte
Erkunden Sie als Nächstes andere Inferenz-Apps. AWS IoT Greengrass stellt weitere Lambda-Funktionen bereit, mit denen Sie lokale Inferenz ausprobieren können. Sie finden das Beispielpaket im Ordner der vorkompilierten Bibliotheken, den Sie unter [Schritt 2: Installieren Sie das Framework MXNet](#install-mxnet) heruntergeladen haben.
## Konfigurieren eines Intel Atom
Um dieses Tutorial auf einem Intel Atom-Gerät auszuführen, müssen Sie Quellbilder bereitstellen, die Lambda-Funktion konfigurieren und eine weitere lokale Geräteressource hinzufügen. Um die GPU für die Inferenz zu verwenden, stellen Sie sicher, dass die folgende Software auf Ihrem Gerät installiert ist:
+ OpenCL Version 1.0 oder höher
+ Python 3.7 und pip
**Anmerkung**
Wenn Ihr Gerät mit Python 3.6 vorkonfiguriert ist, können Sie stattdessen einen Symlink zu Python 3.7 erstellen. Weitere Informationen finden Sie unter [Step 2](#python-symlink).
+ [NumPy](https://pypi.org/project/numpy/)
+ [OpenCV on Wheels](https://pypi.org/project/opencv-python/)
1. Laden Sie statische PNG- oder JPG-Bilder für die Lambda-Funktion herunter, um sie für die Bildklassifizierung zu verwenden. Das Beispiel funktioniert am besten mit kleinen Bilddateien.
Speichern Sie Ihre Bilddateien in dem Verzeichnis mit der `greengrassObjectClassification.py`-Datei (oder in einem Unterverzeichnis dieses Verzeichnisses). Dies ist im Lambda-Funktionsbereitstellungspaket enthalten, in [Schritt 4: Eine Lambda-Funktion erstellen und veröffentlichen](#ml-console-create-lambda) das Sie hochladen.
**Anmerkung**
Wenn Sie die Kamera verwenden AWS DeepLens, können Sie die integrierte Kamera verwenden oder Ihre eigene Kamera montieren, um Rückschlüsse auf aufgenommene Bilder statt auf statische Bilder zu ziehen. Wir empfehlen jedoch nachdrücklich, zunächst mit statischen Bildern zu beginnen.
Wenn Sie eine Kamera verwenden, stellen Sie sicher, dass das `awscam`-APT-Paket installiert und auf dem neuesten Stand ist. Weitere Informationen finden Sie im *AWS DeepLens Entwicklerhandbuch* unter [Ihr AWS DeepLens Gerät aktualisieren](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html).
1. Wenn Sie Python 3.7 nicht verwenden, stellen Sie sicher, dass Sie einen Symlink von Python 3.x zu Python 3.7 erstellen. Dadurch wird Ihr Gerät für die Verwendung von Python 3 konfiguriert. AWS IoT Greengrass Führen Sie den folgenden Befehl aus, um Ihre Python-Installation zu suchen:
```
which python3
```
Führen Sie den folgenden Befehl aus, um den Symlink zu erstellen.
```
sudo ln -s path-to-python-3.x/python3.x path-to-python-3.7/python3.7
```
Starten Sie das Gerät neu.
1. Bearbeiten Sie die Konfiguration der Lambda-Funktion. Folgen Sie dem Verfahren unter [Schritt 5: Fügen Sie die Lambda-Funktion zur Greengrass-Gruppe hinzu](#ml-console-config-lambda).
**Anmerkung**
Wir empfehlen, dass Sie Ihre Lambda-Funktion ohne Containerisierung ausführen, sofern Ihr Geschäftsszenario dies nicht erfordert. Auf diese Weise können Sie auf die GPU und Kamera Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen. Wenn Sie ohne Containerisierung arbeiten, müssen Sie auch Root-Zugriff auf Ihre AWS IoT Greengrass Lambda-Funktionen gewähren.
1. **Um ohne Containerisierung zu laufen:**
+ Wählen Sie für **Systembenutzer und Gruppe** die Option. **Another user ID/group ID** Geben Sie als **Systembenutzer-ID** ein**0**. Geben Sie als **Systemgruppen-ID** ein**0**.
Dadurch kann Ihre Lambda-Funktion als Root ausgeführt werden. Weitere Hinweise zur Ausführung als Root finden Sie unter[Einstellung der Standardzugriffsidentität für Lambda-Funktionen in einer Gruppe](lambda-group-config.md#lambda-access-identity-groupsettings).
**Tipp**
Sie müssen Ihre `config.json` Datei auch aktualisieren, um Root-Zugriff auf Ihre Lambda-Funktion zu gewähren. Informationen zum Verfahren finden Sie unter[Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root).
+ **Wählen Sie für die **Containerisierung von Lambda-Funktionen** die Option Kein Container aus.**
Weitere Hinweise zur Ausführung ohne Containerisierung finden Sie unter. [Überlegungen bei der Wahl der Containerisierung von Lambda-Funktionen](lambda-group-config.md#lambda-containerization-considerations)
+ Aktualisieren Sie den Wert für **Timeout** auf 5 Sekunden. Dies stellt sicher, dass die Zeit für die Anforderung nicht zu schnell überschritten wird. Nach der Einrichtung dauert es einige Minuten, bis die Inferenz ausgeführt wird.
+ **Wählen Sie unter **Fixiert die Option True aus**.**
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
+ Wählen Sie für **Lambda-Lebenszyklus** die Option **Diese Funktion langlebig einstellen und unbegrenzt ausführen** aus.
1. **Um stattdessen im containerisierten Modus zu starten:**
**Anmerkung**
Wir empfehlen nicht, im containerisierten Modus zu arbeiten, es sei denn, Ihr Geschäftsszenario erfordert dies.
+ Aktualisieren Sie den Wert für **Timeout** auf 5 Sekunden. Dies stellt sicher, dass die Zeit für die Anforderung nicht zu schnell überschritten wird. Nach der Einrichtung dauert es einige Minuten, bis die Inferenz ausgeführt wird.
+ **Wählen Sie für **Pinned** die Option True aus.**
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
1. **Wenn es im containerisierten Modus ausgeführt** wird, fügen Sie die erforderliche lokale Geräteressource hinzu, um Zugriff auf die GPU Ihres Geräts zu gewähren.
**Anmerkung**
Wenn Sie im Modus ohne Container arbeiten, AWS IoT Greengrass können Sie auf die GPU Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen.
1. **Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte Ressourcen aus.**
1. Wählen Sie **Lokale Ressource hinzufügen** aus.
1. Definieren Sie die Ressource:
+ Geben Sie für **Resource name (Ressourcenname)** **renderD128** ein.
+ Wählen Sie als **Ressourcentyp** die Option **Lokales Gerät** aus.
+ Geben Sie im Feld **Device path (Gerätepfad)** **/dev/dri/renderD128** ein.
+ Wählen Sie für **Systemgruppenbesitzer und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe, der die Ressource gehört, automatisch hinzufügen** aus.
+ Gewähren **Sie für **Zugehörigkeiten zu Lambda-Funktionen** Lese- und Schreibzugriff auf** Ihre Lambda-Funktion.
## Konfiguration eines NVIDIA Jetson TX2
Um dieses Tutorial auf einem NVIDIA Jetson auszuführen TX2, stellen Sie Quellimages bereit und konfigurieren Sie die Lambda-Funktion. Bei Verwendung der GPU müssen Sie zusätzlich lokale Geräteressourcen hinzufügen.
1. Stellen Sie sicher, dass Ihr Jetson-Gerät so konfiguriert ist, dass Sie die AWS IoT Greengrass Core-Software installieren können. Weitere Informationen zur Konfiguration des Geräts finden Sie unter [Einrichten anderer Geräte](setup-filter.other.md).
1. Öffnen Sie die MXNet Dokumentation, gehen Sie zu [Installation MXNet auf einem Jetson](https://mxnet.apache.org/get_started/jetson_setup) und folgen Sie den Anweisungen zur Installation MXNet auf dem Jetson-Gerät.
**Anmerkung**
Wenn Sie MXNet aus dem Quellcode bauen möchten, folgen Sie den Anweisungen zum Erstellen der gemeinsam genutzten Bibliothek. Bearbeiten Sie die folgenden Einstellungen in Ihrer `config.mk` Datei, um mit einem TX2 Jetson-Gerät zu arbeiten:
Fügen Sie `-gencode arch=compute-62, code=sm_62` der `CUDA_ARCH`-Einstellung hinzu.
Schalten Sie CUDA ein.
```
USE_CUDA = 1
```
1. Laden Sie statische PNG- oder JPG-Bilder für die Lambda-Funktion herunter, um sie für die Bildklassifizierung zu verwenden. Die App funktioniert am besten mit kleinen Bilddateien. Alternativ können Sie eine Kamera auf der Jetson-Karte instrumentieren, um die Quellbilder zu erfassen.
Speichern Sie Ihre Abbilddateien in dem Verzeichnis, das die `greengrassObjectClassification.py`-Datei enthält. Sie können sie auch in einem Unterverzeichnis dieses Verzeichnisses speichern. Dieses Verzeichnis befindet sich im Lambda-Funktionsbereitstellungspaket, in [Schritt 4: Eine Lambda-Funktion erstellen und veröffentlichen](#ml-console-create-lambda) das Sie hochladen.
1. Erstellen Sie einen Symlink von Python 3.7 nach Python 3.6, um Python 3 zu AWS IoT Greengrass verwenden. Führen Sie den folgenden Befehl aus, um Ihre Python-Installation zu suchen:
```
which python3
```
Führen Sie den folgenden Befehl aus, um den Symlink zu erstellen.
```
sudo ln -s path-to-python-3.6/python3.6 path-to-python-3.7/python3.7
```
Starten Sie das Gerät neu.
1. Stellen Sie sicher, dass das `ggc_user` Systemkonto das MXNet Framework verwenden kann:
```
“sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
1. Bearbeiten Sie die Konfiguration der Lambda-Funktion. Folgen Sie dem Verfahren unter [Schritt 5: Fügen Sie die Lambda-Funktion zur Greengrass-Gruppe hinzu](#ml-console-config-lambda).
**Anmerkung**
Wir empfehlen, dass Sie Ihre Lambda-Funktion ohne Containerisierung ausführen, sofern Ihr Geschäftsszenario dies nicht erfordert. Auf diese Weise können Sie auf die GPU und Kamera Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen. Wenn Sie ohne Containerisierung arbeiten, müssen Sie auch Root-Zugriff auf Ihre AWS IoT Greengrass Lambda-Funktionen gewähren.
1. **Um ohne Containerisierung zu laufen:**
+ Wählen Sie für **Systembenutzer und Gruppe** die Option. **Another user ID/group ID** Geben Sie als **Systembenutzer-ID** ein**0**. Geben Sie als **Systemgruppen-ID** ein**0**.
Dadurch kann Ihre Lambda-Funktion als Root ausgeführt werden. Weitere Hinweise zur Ausführung als Root finden Sie unter[Einstellung der Standardzugriffsidentität für Lambda-Funktionen in einer Gruppe](lambda-group-config.md#lambda-access-identity-groupsettings).
**Tipp**
Sie müssen Ihre `config.json` Datei auch aktualisieren, um Root-Zugriff auf Ihre Lambda-Funktion zu gewähren. Informationen zum Verfahren finden Sie unter[Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root).
+ **Wählen Sie für die **Containerisierung von Lambda-Funktionen** die Option Kein Container aus.**
Weitere Hinweise zur Ausführung ohne Containerisierung finden Sie unter. [Überlegungen bei der Wahl der Containerisierung von Lambda-Funktionen](lambda-group-config.md#lambda-containerization-considerations)
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
+ Fügen Sie unter **Umgebungsvariablen** die folgenden Schlüssel-Wert-Paare zu Ihrer Lambda-Funktion hinzu. Dadurch wird die Verwendung des Frameworks konfiguriert AWS IoT Greengrass . MXNet
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/ml-console.html)
1. **Um stattdessen im containerisierten Modus zu laufen:**
**Anmerkung**
Wir empfehlen nicht, im containerisierten Modus zu arbeiten, es sei denn, Ihr Geschäftsszenario erfordert dies.
+ Erhöhen Sie den Wert für **Speicherlimit**. Verwenden Sie 500 MB für die CPU oder mindestens 2000 MB für die GPU.
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
+ Fügen Sie unter **Umgebungsvariablen** die folgenden Schlüssel-Wert-Paare zu Ihrer Lambda-Funktion hinzu. Dadurch wird die Verwendung des Frameworks konfiguriert AWS IoT Greengrass . MXNet
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/ml-console.html)
1. **Wenn es im containerisierten Modus läuft**, fügen Sie die folgenden lokalen Geräteressourcen hinzu, um Zugriff auf die GPU Ihres Geräts zu gewähren. Folgen Sie dem Verfahren unter [Schritt 6: Hinzufügen von Ressourcen zur Greengrass-Gruppe](#ml-console-add-resources).
**Anmerkung**
Wenn Sie im Modus ohne Container arbeiten, AWS IoT Greengrass können Sie auf die GPU Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen.
Für jede Ressource:
+ Wählen Sie in **Resource type (Ressourcentyp)** die Option **Device (Gerät)** aus.
+ Wählen Sie für **Systemgruppenbesitzer- und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe automatisch hinzufügen aus, der die Ressource gehört**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/ml-console.html)
1. **Wenn es im containerisierten Modus läuft**, fügen Sie die folgende lokale Volume-Ressource hinzu, um Zugriff auf Ihre Gerätekamera zu gewähren. Folgen Sie dem Verfahren unter [Schritt 6: Hinzufügen von Ressourcen zur Greengrass-Gruppe](#ml-console-add-resources).
**Anmerkung**
Wenn Sie im Modus ohne Container arbeiten, AWS IoT Greengrass können Sie auf die Kamera Ihres Geräts zugreifen, ohne die Volume-Ressourcen zu konfigurieren.
+ Wählen Sie für **Resource type (Ressourcentyp)** die Option **Volume** aus.
+ Wählen Sie für **Systemgruppenbesitzer und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe automatisch hinzufügen aus, der die Ressource gehört**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/ml-console.html)
# So konfigurieren Sie eine optimierte Inferenz für maschinelles Lernen mit dem AWS-Managementkonsole
Um die Schritte in diesem Tutorial ausführen zu können, müssen Sie AWS IoT Greengrass Core v1.10 oder höher verwenden.
Sie können den SageMaker AI Neo Deep-Learning-Compiler verwenden, um die Prognoseeffizienz nativer Inferenzmodelle für maschinelles Lernen in Tensorflow, Apache MXNet PyTorch, ONNX und XGBoost Frameworks zu optimieren und so einen geringeren Platzbedarf und eine schnellere Leistung zu erzielen. Anschließend können Sie das optimierte Modell herunterladen, die SageMaker AI Neo Deep Learning-Runtime installieren und sie für schnellere Inferenzen auf Ihren AWS IoT Greengrass Geräten bereitstellen.
In diesem Tutorial wird beschrieben, wie Sie eine Greengrass-Gruppe für die AWS-Managementkonsole Ausführung eines Lambda-Inferenzbeispiels verwenden, das Bilder von einer Kamera lokal erkennt, ohne Daten an die Cloud zu senden. Das Inferenzbeispiel greift auf das Kameramodul auf einem Raspberry Pi zu. In diesem Tutorial laden Sie ein vorgefertigtes Modell herunter, das von Resnet-50 trainiert und im Neo Deep Learning-Compiler optimiert wurde. Anschließend verwenden Sie das Modell, um eine lokale Bildklassifizierung auf Ihrem Gerät durchzuführen. AWS IoT Greengrass
Das Tutorial enthält die folgenden allgemeinen Schritte:
1. [Konfigurieren des Raspberry Pi](#config-raspberry-pi-dlc)
1. [Installieren Sie die Neo Deep Learning Runtime](#install-dlr)
1. [Erstellen Sie eine Inferenz-Lambda-Funktion](#ml-console-dlc-create-lambda)
1. [Fügen Sie die Lambda-Funktion zur Gruppe hinzu](#ml-console-dlc-config-lambda)
1. [Hinzufügen einer Neo-optimierten Modellressource zur Gruppe](#ml-console-dlc-add-resources)
1. [Hinzufügen Ihrer Kamerageräte-Ressource zur Gruppe](#ml-console-dlc-add-cam-resource)
1. [Hinzufügen von Abonnements zur Gruppe](#ml-console-dlc-add-subscription)
1. [Bereitstellen der Gruppe](#ml-console-dlc-deploy-group)
1. [Testen des Beispiels](#ml-console-dlc-test-app)
## Voraussetzungen
Zum Durchführen dieses Tutorials benötigen Sie Folgendes:
+ Raspberry Pi 4 Modell B oder Raspberry Pi 3 Modell B/B\$1, eingerichtet und konfiguriert für die Verwendung mit. AWS IoT Greengrass Um Ihren Raspberry Pi mit AWS IoT Greengrass einzurichten, führen Sie das [Greengrass Device Setup-Skript](quick-start.md) aus oder stellen Sie sicher, dass Sie [Modul 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) und [Modul 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) von [Erste Schritte mit AWS IoT Greengrass](gg-gs.md) abgeschlossen haben.
**Anmerkung**
Der Raspberry Pi benötigt möglicherweise eine [2,5-A-Stromversorgung](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/), um die Deep-Learning-Frameworks auszuführen, die normalerweise für die Bildklassifizierung verwendet werden. Ein Netzteil mit einer niedrigeren Nennleistung kann dazu führen, dass das Gerät neu gestartet wird.
+ [Raspberry Pi Kameramodul V2 – 8 Megapixel, 1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Weitere Informationen zum Einrichten der Kamera finden Sie unter [Verbinden der Kamera](https://www.raspberrypi.org/documentation/usage/camera/) in der Raspberry Pi-Dokumentation.
+ Eine Greengrass-Gruppe und ein Greengrass Core. Weitere Informationen zum Erstellen einer Greengrass-Gruppe oder eines Greengrass-Cores finden Sie unter [Erste Schritte mit AWS IoT Greengrass](gg-gs.md).
**Anmerkung**
Dieses Tutorial verwendet einen Raspberry Pi, AWS IoT Greengrass unterstützt aber auch andere Plattformen wie [Intel Atom](#atom-lambda-dlc-config) und [NVIDIA Jetson TX2](#jetson-lambda-dlc-config). Wenn Sie das Intel Atom-Beispiel verwenden, müssen Sie möglicherweise Python 3.6 anstelle von Python 3.7 installieren. Informationen zur Konfiguration Ihres Geräts für die Installation der AWS IoT Greengrass Core-Software finden Sie unter[Einrichten anderer Geräte](setup-filter.other.md).
Für Plattformen von Drittanbietern, die AWS IoT Greengrass dies nicht unterstützen, müssen Sie Ihre Lambda-Funktion im Modus ohne Container ausführen. Um im Modus ohne Container ausgeführt zu werden, müssen Sie Ihre Lambda-Funktion als Root ausführen. Weitere Informationen erhalten Sie unter [Überlegungen bei der Wahl der Containerisierung von Lambda-Funktionen](lambda-group-config.md#lambda-containerization-considerations) und [Einstellung der Standardzugriffsidentität für Lambda-Funktionen in einer Gruppe](lambda-group-config.md#lambda-access-identity-groupsettings).
## Schritt 1: Konfigurieren des Raspberry Pi
In diesem Schritt installieren Sie Updates für das Raspbian-Betriebssystem, installieren die Kameramodulsoftware und Python-Abhängigkeiten und aktivieren die Kameraschnittstelle.
Führen Sie im Raspberry Pi-Terminal die folgenden Befehle aus.
1. Installieren von Updates für Raspbian.
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. Installieren Sie die `picamera`-Schnittstelle für das Kameramodul und andere Python-Bibliotheken, die für dieses Tutorial erforderlich sind.
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
Überprüfen Sie die Installation:
+ Stellen Sie sicher, dass Ihre Python 3.7-Installation pip enthält.
```
python3 -m pip
```
Wenn pip nicht installiert ist, laden Sie es von der [pip-Website](https://pip.pypa.io/en/stable/installing/) herunter und führen Sie dann den folgenden Befehl aus.
```
python3 get-pip.py
```
+ Stellen Sie sicher, dass Ihre Python-Version 3.7 oder höher ist.
```
python3 --version
```
Wenn in der Ausgabe eine frühere Version aufgelistet ist, führen Sie den folgenden Befehl aus.
```
sudo apt-get install -y python3.7-dev
```
+ Stellen Sie sicher, dass Setuptools und Picamera erfolgreich installiert wurden.
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Wenn die Ausgabe keine Fehler enthält, ist die Überprüfung erfolgreich.
**Anmerkung**
Wenn die auf Ihrem Gerät installierte ausführbare Python-Datei `python3.7` ist, verwenden Sie `python3.7` anstelle von `python3` für die Befehle in diesem Tutorial. Stellen Sie sicher, dass Ihre pip-Installation der richtigen `python3.7`- oder `python3`-Version zugeordnet ist, um Abhängigkeitsfehler zu vermeiden.
1. Starten Sie den Raspberry Pi neu.
```
sudo reboot
```
1. Öffnen Sie das Raspberry Pi-Konfigurations-Tool.
```
sudo raspi-config
```
1. Verwenden Sie die Pfeiltasten zum Öffnen von **Interfacing Options** (Verbindungsoptionen) und aktivieren Sie die Kameraschnittstelle. Wenn Sie dazu aufgefordert werden, lassen Sie den Neustart des Geräts zu.
1. Geben Sie den folgenden Befehl ein, um die Einrichtung der Kamera zu testen.
```
raspistill -v -o test.jpg
```
So werden ein Vorschaufenster im Raspberry Pi geöffnet, ein Bild mit dem Namen `test.jpg` in Ihrem aktuellen Verzeichnis gespeichert und Informationen über die Kamera im Raspberry Pi-Terminal angezeigt.
## Schritt 2: Installieren Sie die Amazon SageMaker Neo Deep Learning-Laufzeit
Installieren Sie in diesem Schritt die Neo Deep Learning Runtime (DLR) auf Ihrem Raspberry Pi.
**Anmerkung**
Wir empfehlen, Version 1.1.0 für dieses Tutorial zu installieren.
1. Melden Sie sich per Fernzugriff bei Ihrem Raspberry Pi an.
```
ssh pi@your-device-ip-address
```
1. Öffnen Sie die DLR-Dokumentation, öffnen Sie [Installing DLR](https://neo-ai-dlr.readthedocs.io/en/latest/install.html) und suchen Sie die Wheel-URL für Raspberry Pi-Geräte. Folgen Sie dann den Anweisungen, um die DLR auf Ihrem Gerät zu installieren. Sie können beispielsweise pip verwenden:
```
pip3 install rasp3b-wheel-url
```
1. Überprüfen Sie nach der Installation der DLR die folgende Konfiguration:
+ Stellen Sie sicher, dass das `ggc_user`-Systemkonto die DLR-Bibliothek verwenden kann.
```
sudo -u ggc_user bash -c 'python3 -c "import dlr"'
```
+ Stellen Sie sicher, dass sie installiert NumPy ist.
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## Schritt 3: Erstellen Sie eine Inferenz-Lambda-Funktion
In diesem Schritt erstellen Sie ein Lambda-Funktions-Bereitstellungspaket und eine Lambda-Funktion. Veröffentlichen Sie anschließend eine Funktionsversion und erstellen einen Alias.
1. Laden Sie auf Ihrem Computer das DLR-Beispiel für Raspberry Pi von [Beispiele für Machine Learning](what-is-gg.md#gg-ml-samples) herunter.
1. Entpacken Sie die heruntergeladene `dlr-py3-armv7l.tar.gz`-Datei.
```
cd path-to-downloaded-sample
tar -xvzf dlr-py3-armv7l.tar.gz
```
Das `examples`-Verzeichnis im extrahierten Beispielpaket enthält Funktionscode und Abhängigkeiten.
+ `inference.py` ist der in diesem Tutorial verwendete Inferenzcode. Sie können diesen Code als Vorlage verwenden, um eine eigene Inferenzfunktion zu erstellen.
+ `greengrasssdk`ist Version 1.5.0 des AWS IoT Greengrass Core SDK für Python.
**Anmerkung**
Wenn eine neue Version verfügbar ist, können Sie sie herunterladen und die SDK-Version in Ihrem Bereitstellungspaket aktualisieren. Weitere Informationen finden Sie unter [AWS IoT Greengrass Core SDK for Python](https://github.com/aws/aws-greengrass-core-sdk-python/) on GitHub.
1. Komprimieren Sie den Inhalt des `examples`-Verzeichnisses in eine Datei namens `optimizedImageClassification.zip`. Dies ist Ihr Bereitstellungspaket.
```
cd path-to-downloaded-sample/dlr-py3-armv7l/examples
zip -r optimizedImageClassification.zip .
```
Das Bereitstellungspaket enthält den Funktionscode und die Abhängigkeiten. Dazu gehört der Code, der die Neo-Deep-Learning-Laufzeit Python aufruft, APIs um Inferenzen mit den Neo-Deep-Learning-Compilermodellen durchzuführen.
**Anmerkung**
Stellen Sie sicher, dass sich die `.py`-Dateien und -Abhängigkeiten im Stammverzeichnis befinden.
1. Fügen Sie nun die Lambda-Funktion zu Ihrer Greengrass-Gruppe hinzu.
Wählen Sie auf der Lambda-Konsolenseite **Funktionen** und dann **Funktion erstellen** aus.
1. Wählen Sie **Author von Grund auf neu** und verwenden Sie die folgenden Werte, um Ihre Funktion zu erstellen:
+ Geben Sie für **Function name** (Funktionsname) **optimizedImageClassification** ein.
+ Wählen Sie für **Runtime (Laufzeit)** die Option **Python 3.7** aus.
Behalten Sie für **Berechtigungen** die Standardeinstellung bei. Dadurch wird eine Ausführungsrolle erstellt, die grundlegende Lambda-Berechtigungen gewährt. Diese Rolle wird nicht verwendet von AWS IoT Greengrass.
![\[Der Abschnitt Basisinformationen auf der der Seite Funktion erstellen.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/ml-dlc-inference/gg-dlr-lambda-creation.png)
1. Wählen Sie **Funktion erstellen**.
Laden Sie jetzt Ihr Lambda-Funktionsbereitstellungspaket hoch und registrieren Sie den Handler.
1. Wählen Sie auf der Registerkarte **Code** unter **Codequelle** die Option **Hochladen von aus**. Wählen Sie in der Dropdownliste die **ZIP-Datei** aus.
![\[Das Drop-down-Menü „Von hochladen“, wobei die ZIP-Datei hervorgehoben ist.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. **Wählen Sie Ihr `optimizedImageClassification.zip` Bereitstellungspaket und dann Speichern aus.**
1. Wählen Sie auf der Registerkarte **Code** für die Funktion unter **Laufzeiteinstellungen** die Option **Bearbeiten** aus, und geben Sie dann die folgenden Werte ein.
+ Wählen Sie für **Runtime (Laufzeit)** die Option **Python 3.7** aus.
+ Geben Sie unter **Handler** **inference.handler** ein.
Wählen Sie **Speichern**.
![\[Der Abschnitt mit den Runtime-Einstellungen, in dem Upload hervorgehoben ist.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-lambda-upload.png)
Veröffentlichen Sie als Nächstes die erste Version Ihrer Lambda-Funktion. Anschließend erstellen Sie einen [Alias für die Version](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html).
**Anmerkung**
Greengrass-Gruppen können eine Lambda-Funktion nach Alias (empfohlen) oder nach Version referenzieren. Die Verwendung eines Alias erleichtert die Verwaltung von Codeaktualisierungen, da Sie Ihre Abonnementtabelle oder Gruppendefinition nicht ändern müssen, wenn der Funktionscode aktualisiert wird. Stattdessen verweisen Sie einfach mit dem Alias auf die neue Funktionsversion.
1. Wählen Sie im Menü **Actions** die Option **Publish new version** aus.
![\[Menü „Actions“ mit der Option „Publish new version“.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-publish-new.png)
1. Geben Sie unter **Version description (Versionsbeschreibung)** den Wert **First version** ein und wählen Sie dann **Publish (Veröffentlichen)** aus.
1. Wählen Sie auf der Konfigurationsseite **optimizedImageClassification: 1** im Menü **Aktionen** die Option **Alias erstellen** aus.
![\[Menü „Actions“ mit der Option „Create alias“\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-create-alias.png)
1. Geben Sie auf der Seite **Create a new alias** folgende Werte an:
+ Geben Sie unter **Name** **mlTestOpt** ein.
+ Geben Sie in **Version (Version)** **1** ein.
**Anmerkung**
AWS IoT Greengrass unterstützt keine Lambda-Aliase für **\$1LATEST-Versionen**.
1. Wählen Sie **Erstellen** aus.
Fügen Sie nun die Lambda-Funktion zu Ihrer Greengrass-Gruppe hinzu.
## Schritt 4: Fügen Sie die Lambda-Funktion zur Greengrass-Gruppe hinzu
Fügen Sie in diesem Schritt die Lambda-Funktion zur Gruppe hinzu und konfigurieren Sie dann ihren Lebenszyklus.
Fügen Sie zunächst die Lambda-Funktion zu Ihrer Greengrass-Gruppe hinzu.
1. Erweitern Sie im Navigationsbereich der AWS IoT Konsole unter **Verwalten** die Option **Greengrass-Geräte** und wählen Sie dann **Gruppen (V1)** aus.
1. Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte **Lambda-Funktionen** und dann **Hinzufügen** aus.
1. Wählen Sie die **Lambda-Funktion** und wählen Sie **optimizedImageClassification**.
1. Wählen Sie in der **Lambda-Funktionsversion** den Alias für die Version aus, die Sie veröffentlicht haben.
Als Nächstes konfigurieren Sie den Lebenszyklus der Lambda-Funktion.
1. Nehmen Sie im Abschnitt **Lambda-Funktionskonfiguration** die folgenden Aktualisierungen vor.
**Anmerkung**
Wir empfehlen, dass Sie Ihre Lambda-Funktion ohne Containerisierung ausführen, sofern Ihr Geschäftsszenario dies nicht erfordert. Auf diese Weise können Sie auf die GPU und Kamera Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen. Wenn Sie ohne Containerisierung arbeiten, müssen Sie auch Root-Zugriff auf Ihre AWS IoT Greengrass Lambda-Funktionen gewähren.
1. **Um ohne Containerisierung zu laufen:**
+ Wählen Sie für **Systembenutzer und Gruppe** die Option. **Another user ID/group ID** Geben Sie als **Systembenutzer-ID** ein**0**. Geben Sie als **Systemgruppen-ID** ein**0**.
Dadurch kann Ihre Lambda-Funktion als Root ausgeführt werden. Weitere Hinweise zur Ausführung als Root finden Sie unter[Einstellung der Standardzugriffsidentität für Lambda-Funktionen in einer Gruppe](lambda-group-config.md#lambda-access-identity-groupsettings).
**Tipp**
Sie müssen Ihre `config.json` Datei auch aktualisieren, um Root-Zugriff auf Ihre Lambda-Funktion zu gewähren. Informationen zum Verfahren finden Sie unter[Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root).
+ **Wählen Sie für die **Containerisierung von Lambda-Funktionen** die Option Kein Container aus.**
Weitere Hinweise zur Ausführung ohne Containerisierung finden Sie unter. [Überlegungen bei der Wahl der Containerisierung von Lambda-Funktionen](lambda-group-config.md#lambda-containerization-considerations)
+ Geben Sie in **Timeout (Zeitüberschreitung)** **10 seconds** ein.
+ **Wählen Sie für **Pinned** die Option True aus.**
Weitere Informationen finden Sie unter [Lebenszykluskonfiguration für Greengrass Lambda-Funktionen](lambda-functions.md#lambda-lifecycle).
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
1. **Um stattdessen im containerisierten Modus zu starten:**
**Anmerkung**
Wir empfehlen nicht, im containerisierten Modus zu arbeiten, es sei denn, Ihr Geschäftsszenario erfordert dies.
+ Wählen Sie für **Systembenutzer und Gruppe** die Option **Gruppenstandard verwenden** aus.
+ Wählen Sie für die **Containerisierung von Lambda-Funktionen** die Option Gruppenstandard **verwenden** aus.
+ Geben Sie in **Memory Limit (Speicherlimit)** **1024 MB** ein.
+ Geben Sie in **Timeout (Zeitüberschreitung)** **10 seconds** ein.
+ **Wählen Sie für **Pinned** die Option True aus.**
Weitere Informationen finden Sie unter [Lebenszykluskonfiguration für Greengrass Lambda-Funktionen](lambda-functions.md#lambda-lifecycle).
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
1. Wählen Sie **Lambda-Funktion hinzufügen**.
## Schritt 5: Fügen Sie der SageMaker Greengrass-Gruppe eine KI-NEO-optimierte Modellressource hinzu
In diesem Schritt erstellen Sie eine Ressource für das optimierte ML-Inferenzmodell und laden Sie sie in einen Amazon S3 S3-Bucket hoch. Suchen Sie dann das hochgeladene Amazon S3 S3-Modell in der AWS IoT Greengrass Konsole und verknüpfen Sie die neu erstellte Ressource mit der Lambda-Funktion. Dies ermöglicht es der Funktion, auf ihre Ressourcen auf dem Core-Gerät zuzugreifen.
1. Navigieren Sie auf Ihrem Computer zum `resnet50`-Verzeichnis im Beispielpaket, das Sie in [Schritt 3: Erstellen Sie eine Inferenz-Lambda-Funktion](#ml-console-dlc-create-lambda) entpackt haben.
**Anmerkung**
Wenn Sie das NVIDIA Jetson-Beispiel verwenden, müssen Sie stattdessen das `resnet18`-Verzeichnis im Beispielpaket verwenden. Weitere Informationen finden Sie unter [Konfiguration eines NVIDIA Jetson TX2](#jetson-lambda-dlc-config).
```
cd path-to-downloaded-sample/dlr-py3-armv7l/models/resnet50
```
Dieses Verzeichnis enthält vorkompilierte Modellartefakte für ein mit Resnet-50 trainiertes Bildklassifikationsmodell.
1. Komprimieren Sie die Dateien innerhalb des `resnet50`-Verzeichnisses in eine Datei namens `resnet50.zip`.
```
zip -r resnet50.zip .
```
1. Wählen Sie auf der Gruppenkonfigurationsseite für Ihre AWS IoT Greengrass Gruppe den Tab **Ressourcen** aus. Navigieren Sie zum Abschnitt **Machine Learning** und wählen Sie **Add machine learning resource (Maschinelle Lernressource hinzufügen)** aus. Geben Sie auf der Seite **Eine maschinelle Lernressource erstellen** für **Ressourcenname** **resnet50\$1model** ein.
1. Wählen Sie als **Modellquelle** die Option **Ein in S3 gespeichertes Modell verwenden aus, z. B. ein mit dem Deep Learning Compiler optimiertes Modell**.
1. Wählen Sie unter **S3-URI** die Option **Browse S3** aus.
**Anmerkung**
Derzeit werden optimierte SageMaker KI-Modelle automatisch in Amazon S3 gespeichert. Mit dieser Option können Sie Ihr optimiertes Modell in Ihrem Amazon S3 S3-Bucket finden. Weitere Informationen zur Modelloptimierung in SageMaker KI finden Sie in der [SageMaker AI Neo-Dokumentation](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
1. Wählen Sie **Upload a model (Ein Modell hochladen)**.
1. Laden Sie auf der Registerkarte Amazon S3 S3-Konsole Ihre ZIP-Datei in einen Amazon S3 S3-Bucket hoch. Weitere Informationen finden Sie unter [Wie lade ich Dateien und Ordner in einen S3-Bucket hoch?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.
**Anmerkung**
Ihr Bucket-Name muss die Zeichenfolge **greengrass** enthalten. Wählen Sie einen eindeutigen Namen (wie z. B.: **greengrass-dlr-bucket-*user-id*-*epoch-time***). Verwenden Sie keinen Punkt (`.`) im Bucket-Namen.
1. Suchen Sie auf der Registerkarte „ AWS IoT Greengrass Konsole“ Ihren Amazon S3 S3-Bucket und wählen Sie ihn aus. Suchen Sie Ihre hochgeladene Datei `resnet50.zip` und wählen Sie **Select (Auswählen)**. Möglicherweise müssen Sie die Seite aktualisieren, um die Liste der verfügbaren Buckets und Dateien zu aktualisieren.
1. Geben Sie im Feld **Zielpfad** den Wert ein**/ml\$1model**.
![\[Der aktualisierte Zielpfad.\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/images/ml-dlc-inference/local-path.png)
Dies ist das Ziel für das lokale Modell im Lambda-Laufzeit-Namespace. Wenn Sie die Gruppe bereitstellen, AWS IoT Greengrass ruft das Quellmodellpaket ab und extrahiert dann den Inhalt in das angegebene Verzeichnis.
**Anmerkung**
Wir empfehlen Ihnen dringend, den genauen Pfad für Ihren lokalen Pfad zu verwenden. Die Verwendung eines anderen lokalen Modellzielverzeichnisses in diesem Schritt führt dazu, dass einige in diesem Tutorial enthaltene Befehle zur Fehlerbehebung ungenau sind. Wenn Sie einen anderen Pfad verwenden, müssen Sie eine `MODEL_PATH`-Umgebungsvariable einrichten, die genau den von Ihnen hier angegebenen Pfad verwendet. Weitere Informationen zu Umgebungsvariablen finden Sie unter [AWS Lambda -Umgebungsvariablen](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html).
1. **Bei Ausführung im containerisierten Modus:**
1. Wählen Sie unter **Systemgruppenbesitzer- und Dateizugriffsberechtigungen** die Option **Systemgruppe und Berechtigungen angeben** aus.
1. Wählen Sie **Nur-Lese-Zugriff** und anschließend Ressource **hinzufügen** aus.
## Schritt 6: Hinzufügen einer Kamerageräte-Ressource zur Greengrass-Gruppe
Erstellen Sie in diesem Schritt eine Ressource für das Kameramodul und verknüpfen Sie sie mit der Lambda-Funktion. Dadurch kann die Lambda-Funktion auf die Ressource auf dem Kerngerät zugreifen.
**Anmerkung**
Wenn Sie im Modus ohne Container arbeiten, AWS IoT Greengrass können Sie auf die GPU und Kamera Ihres Geräts zugreifen, ohne diese Geräteressource zu konfigurieren.
1. **Wählen Sie auf der Seite mit der Gruppenkonfiguration die Registerkarte Ressourcen aus.**
1. Wählen Sie auf der Registerkarte **Lokale Ressourcen** die Option **Lokale Ressource hinzufügen** aus.
1. Verwenden Sie auf der Seite **Lokale Ressource hinzufügen** die folgenden Werte:
+ Geben Sie für **Resource name (Ressourcenname)** **videoCoreSharedMemory** ein.
+ Wählen Sie in **Resource type (Ressourcentyp)** die Option **Device (Gerät)** aus.
+ Geben Sie für **Lokaler Gerätepfad** den Wert ein**/dev/vcsm**.
Der Gerätepfad ist der lokale absolute Pfad der Geräteressource. Dieser Pfad kann nur auf ein zeichenorientiertes Gerät oder Blockgerät unter `/dev` verweisen.
+ Wählen Sie für **Systemgruppenbesitzer und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe, der die Ressource gehört, automatisch hinzufügen** aus.
Mit der Option **Group owner file access permission** (Dateizugriffsberechtigung des Gruppenbesitzers) können Sie zusätzliche Dateizugriffsberechtigungen für den Lambda-Prozess erteilen. Weitere Informationen finden Sie unter [Dateizugriffsberechtigung des Gruppenbesitzers](access-local-resources.md#lra-group-owner).
1. Wählen Sie unten auf der Seite die Option **Ressource hinzufügen** aus.
1. Erstellen Sie auf der Registerkarte **Ressourcen** eine weitere lokale Ressource, indem **Sie Hinzufügen** wählen und die folgenden Werte verwenden:
+ Geben Sie für **Resource name (Ressourcenname)** **videoCoreInterface** ein.
+ Wählen Sie in **Resource type (Ressourcentyp)** die Option **Device (Gerät)** aus.
+ Geben Sie für **Lokaler Gerätepfad** den Wert ein**/dev/vchiq**.
+ Wählen Sie für **Systemgruppenbesitzer und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe, der die Ressource gehört, automatisch hinzufügen** aus.
1. Wählen Sie **Add resource (Ressource hinzufügen)** aus.
## Schritt 7: Hinzufügen von Abonnements zur Greengrass-Gruppe
In diesem Schritt fügen Sie der Gruppe Abonnements hinzu. Diese Abonnements ermöglichen es der Lambda-Funktion, Vorhersageergebnisse zu senden, AWS IoT indem sie sie in einem MQTT-Thema veröffentlichen.
1. Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte **Abonnements** und dann Abonnement **hinzufügen** aus.
1. Konfigurieren Sie auf der Seite **Abonnement erstellen** die Quelle und das Ziel wie folgt:
1. Wählen Sie **unter Quelltyp** die Option **Lambda-Funktion** und dann aus **optimizedImageClassification**.
1. Wählen Sie **unter Zieltyp** die Option **Service** und dann **IoT Cloud** aus.
1. Geben Sie im **Themenfilter** Folgendes ein **/resnet-50/predictions** und wählen Sie dann **Abonnement erstellen** aus.
1. Hinzufügen eines zweiten Abonnements. Wählen Sie die Registerkarte **Abonnements** aus, wählen **Sie Abonnement hinzufügen** und konfigurieren Sie Quelle und Ziel wie folgt:
1. Wählen Sie **unter Quelltyp** die Option **Dienste** und dann **IoT Cloud** aus.
1. Wählen Sie **unter Zieltyp** die Option **Lambda-Funktion** und dann aus **optimizedImageClassification**.
1. Geben Sie **/resnet-50/test** im **Themenfilter Folgendes** ein und wählen Sie dann **Create subscription** aus.
## Schritt 8: Bereitstellen der Greengrass-Gruppe
In diesem Schritt stellen Sie die aktuelle Version der Gruppendefinition für das Greengrass Core-Gerät bereit. Die Definition enthält die Lambda-Funktion, die Ressourcen und die Abonnementkonfigurationen, die Sie hinzugefügt haben.
1. Stellen Sie sicher, dass der AWS IoT Greengrass Core läuft. Führen Sie im Raspberry Pi-Terminal die folgenden Befehle aus, falls nötig.
1. So prüfen Sie, ob der Daemon ausgeführt wird:
```
ps aux | grep -E 'greengrass.*daemon'
```
Wenn die Ausgabe einen `root`-Eintrag für `/greengrass/ggc/packages/latest-core-version/bin/daemon` enthält, dann wird der Daemon ausgeführt.
1. Um den Daemon zu starten:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Wählen Sie auf der Seite mit der Gruppenkonfiguration die Option **Deploy** aus.
1. Wählen Sie auf der Registerkarte **Lambda-Funktionen** die Option **IP-Detektor** und dann **Bearbeiten** aus.
1. **Wählen **Sie im Dialogfeld IP-Detektoreinstellungen bearbeiten** die Option **MQTT-Broker-Endpunkte automatisch erkennen und überschreiben** aus und wählen Sie Speichern aus.**
Damit können Geräte automatisch Core-Verbindungsinformationen abrufen, z. B. die IP-Adresse, DNS und die Portnummer. Eine automatische Erkennung wird empfohlen, unterstützt aber AWS IoT Greengrass auch manuell angegebene Endpunkte. Sie werden nur bei der ersten Bereitstellung der Gruppe zur Angabe der Ermittlungsmethode aufgefordert.
**Anmerkung**
Wenn Sie dazu aufgefordert werden, erteilen Sie die Erlaubnis, die [Greengrass-Servicerolle zu erstellen und sie Ihrer AWS-Konto aktuellen AWS-Region Rolle](service-role.md) zuzuordnen. Diese Rolle ermöglicht AWS IoT Greengrass den Zugriff auf Ihre Ressourcen in AWS Diensten.
Auf der Seite **Deployments** werden der Zeitstempel, die Versions-ID und der Status der Bereitstellung angegeben. Nach Abschluss sollte der für die Bereitstellung angezeigte Status **Abgeschlossen** lauten.
Weitere Informationen über Bereitstellungen finden Sie unter [AWS IoT Greengrass Gruppen für einen AWS IoT Greengrass Kern bereitstellen](deployments.md). Hilfe zur Problembehebung finden Sie unter [Problembehebung AWS IoT Greengrass](gg-troubleshooting.md).
## Testen des Inferenzbeispiels
Nun können Sie prüfen, ob die Bereitstellung korrekt konfiguriert ist. Um zu testen, abonnieren Sie das Thema `/resnet-50/predictions` und veröffentlichen Sie jede Nachricht zum `/resnet-50/test`-Thema. Dadurch wird die Lambda-Funktion ausgelöst, um ein Foto mit Ihrem Raspberry Pi aufzunehmen und Rückschlüsse auf das aufgenommene Bild zu ziehen.
**Anmerkung**
Wenn Sie das NVIDIA Jetson-Beispiel verwenden, stellen Sie sicher, dass Sie stattdessen die Themen `resnet-18/predictions` und `resnet-18/test` verwenden.
**Anmerkung**
Wenn ein Bildschirm mit dem Raspberry Pi verbunden ist, wird das Livebild der Kamera in einem Vorschaufenster angezeigt.
1. Wählen Sie auf der Startseite der AWS IoT Konsole unter **Test** die Option **MQTT-Testclient** aus.
1. Wählen Sie für **Abonnements** die Option **Thema abonnieren aus**. Verwenden Sie die folgenden Werte. Übernehmen Sie für die verbleibenden Optionen die Standardwerte.
+ Geben Sie für **Abonnementthema** **/resnet-50/predictions** ein.
+ Wählen Sie unter **Zusätzliche Konfiguration** für die **Anzeige von MQTT-Payloads die Option Payloads** **als Zeichenketten anzeigen** aus.
1. Wählen Sie **Subscribe (Abonnieren)** aus.
1. **Wählen Sie In **einem Thema veröffentlichen**, geben Sie es **/resnet-50/test** als **Themennamen** ein und wählen Sie Veröffentlichen.**
1. Wenn der Test erfolgreich ist, veranlasst die veröffentlichte Nachricht die Raspberry Pi-Kamera, ein Bild aufzunehmen. Eine Meldung der Lambda-Funktion wird unten auf der Seite angezeigt. Diese Meldung enthält das Vorhersageergebnis des Bildes im Format: vorhergesagter Klassenname, Wahrscheinlichkeit und maximaler Speicherverbrauch.
## Konfigurieren eines Intel Atom
Um dieses Tutorial auf einem Intel Atom-Gerät auszuführen, müssen Sie Quellbilder bereitstellen, die Lambda-Funktion konfigurieren und eine weitere lokale Geräteressource hinzufügen. Um die GPU für die Inferenz zu verwenden, stellen Sie sicher, dass die folgende Software auf Ihrem Gerät installiert ist:
+ OpenCL Version 1.0 oder höher
+ Python 3.7 und pip
+ [NumPy](https://pypi.org/project/numpy/)
+ [OpenCV on Wheels](https://pypi.org/project/opencv-python/)
1. Laden Sie statische PNG- oder JPG-Bilder für die Lambda-Funktion herunter, um sie für die Bildklassifizierung zu verwenden. Das Beispiel funktioniert am besten mit kleinen Bilddateien.
Speichern Sie Ihre Bilddateien in dem Verzeichnis mit der `inference.py`-Datei (oder in einem Unterverzeichnis dieses Verzeichnisses). Dies ist im Lambda-Funktionsbereitstellungspaket enthalten, in [Schritt 3: Erstellen Sie eine Inferenz-Lambda-Funktion](#ml-console-dlc-create-lambda) das Sie hochladen.
**Anmerkung**
Wenn Sie die Kamera verwenden AWS DeepLens, können Sie die integrierte Kamera verwenden oder Ihre eigene Kamera montieren, um Rückschlüsse auf aufgenommene Bilder statt auf statische Bilder zu ziehen. Wir empfehlen jedoch nachdrücklich, zunächst mit statischen Bildern zu beginnen.
Wenn Sie eine Kamera verwenden, stellen Sie sicher, dass das `awscam`-APT-Paket installiert und auf dem neuesten Stand ist. Weitere Informationen finden Sie im *AWS DeepLens Entwicklerhandbuch* unter [Ihr AWS DeepLens Gerät aktualisieren](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html).
1. Bearbeiten Sie die Konfiguration der Lambda-Funktion. Folgen Sie dem Verfahren unter [Schritt 4: Fügen Sie die Lambda-Funktion zur Greengrass-Gruppe hinzu](#ml-console-dlc-config-lambda).
**Anmerkung**
Wir empfehlen, dass Sie Ihre Lambda-Funktion ohne Containerisierung ausführen, sofern Ihr Geschäftsszenario dies nicht erfordert. Auf diese Weise können Sie auf die GPU und Kamera Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen. Wenn Sie ohne Containerisierung arbeiten, müssen Sie auch Root-Zugriff auf Ihre AWS IoT Greengrass Lambda-Funktionen gewähren.
1. **Um ohne Containerisierung zu laufen:**
+ Wählen Sie für **Systembenutzer und Gruppe** die Option. **Another user ID/group ID** Geben Sie als **Systembenutzer-ID** ein**0**. Geben Sie als **Systemgruppen-ID** ein**0**.
Dadurch kann Ihre Lambda-Funktion als Root ausgeführt werden. Weitere Hinweise zur Ausführung als Root finden Sie unter[Einstellung der Standardzugriffsidentität für Lambda-Funktionen in einer Gruppe](lambda-group-config.md#lambda-access-identity-groupsettings).
**Tipp**
Sie müssen Ihre `config.json` Datei auch aktualisieren, um Root-Zugriff auf Ihre Lambda-Funktion zu gewähren. Informationen zum Verfahren finden Sie unter[Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root).
+ **Wählen Sie für die **Containerisierung von Lambda-Funktionen** die Option Kein Container aus.**
Weitere Hinweise zur Ausführung ohne Containerisierung finden Sie unter. [Überlegungen bei der Wahl der Containerisierung von Lambda-Funktionen](lambda-group-config.md#lambda-containerization-considerations)
+ Erhöhen Sie den Wert für **Timeout** auf 2 Minuten. Dies stellt sicher, dass die Zeit für die Anforderung nicht zu schnell überschritten wird. Nach der Einrichtung dauert es einige Minuten, bis die Inferenz ausgeführt wird.
+ **Wählen Sie für **Pinned** die Option True aus.**
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
1. **Um stattdessen im containerisierten Modus zu starten:**
**Anmerkung**
Wir empfehlen nicht, im containerisierten Modus zu arbeiten, es sei denn, Ihr Geschäftsszenario erfordert dies.
+ Erhöhen Sie den Wert für **Speicherlimit** auf 3000 MB.
+ Erhöhen Sie den Wert für **Timeout** auf 2 Minuten. Dies stellt sicher, dass die Zeit für die Anforderung nicht zu schnell überschritten wird. Nach der Einrichtung dauert es einige Minuten, bis die Inferenz ausgeführt wird.
+ **Wählen Sie für **Pinned** die Option True aus.**
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
1. Fügen Sie Ihrer Neo-optimierten Modellressource der Gruppe hinzu. Laden Sie die Modellressourcen in das `resnet50`-Verzeichnis des Beispielpakets hoch, das Sie in [Schritt 3: Erstellen Sie eine Inferenz-Lambda-Funktion](#ml-console-dlc-create-lambda) entpackt haben. Dieses Verzeichnis enthält vorkompilierte Modellartefakte für ein mit Resnet-50 trainiertes Bildklassifikationsmodell. Folgen Sie dem Verfahren unter [Schritt 5: Fügen Sie der SageMaker Greengrass-Gruppe eine KI-NEO-optimierte Modellressource hinzu](#ml-console-dlc-add-resources) mit den folgenden Updates:
+ Komprimieren Sie die Dateien innerhalb des `resnet50`-Verzeichnisses in eine Datei namens `resnet50.zip`.
+ Geben Sie auf der Seite **Eine maschinelle Lernressource erstellen** für **Ressourcenname** **resnet50\$1model** ein.
+ Hochladen der `resnet50.zip`-Datei
1. **Wenn es im containerisierten Modus ausgeführt** wird, fügen Sie die erforderliche lokale Geräteressource hinzu, um Zugriff auf die GPU Ihres Geräts zu gewähren.
**Anmerkung**
Wenn Sie im Modus ohne Container arbeiten, AWS IoT Greengrass können Sie auf die GPU Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen.
1. **Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte Ressourcen aus.**
1. Wählen Sie im Abschnitt **Lokale Ressourcen** die Option **Lokale Ressource hinzufügen** aus.
1. Definieren Sie die Ressource:
+ Geben Sie für **Resource name (Ressourcenname)** **renderD128** ein.
+ Wählen Sie in **Resource type (Ressourcentyp)** die Option **Device (Gerät)** aus.
+ Geben Sie für **Lokaler Gerätepfad** den Wert ein**/dev/dri/renderD128**.
+ Wählen Sie für **Systemgruppenbesitzer und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe, der die Ressource gehört, automatisch hinzufügen** aus.
## Konfiguration eines NVIDIA Jetson TX2
Um dieses Tutorial auf einem NVIDIA Jetson auszuführen TX2, stellen Sie Quellimages bereit, konfigurieren Sie die Lambda-Funktion und fügen Sie weitere lokale Geräteressourcen hinzu.
1. Stellen Sie sicher, dass Ihr Jetson-Gerät so konfiguriert ist, dass Sie die AWS IoT Greengrass Core-Software installieren und die GPU als Inferenz verwenden können. Weitere Informationen zur Konfiguration des Geräts finden Sie unter [Einrichten anderer Geräte](setup-filter.other.md). Um die GPU für Inferenz auf einem NVIDIA Jetson zu verwenden TX2, müssen Sie CUDA 10.0 und cuDNN 7.0 auf Ihrem Gerät installieren, wenn Sie Ihr Board mit Jetpack 4.3 abbilden.
1. Laden Sie statische PNG- oder JPG-Bilder für die Lambda-Funktion herunter, um sie für die Bildklassifizierung zu verwenden. Das Beispiel funktioniert am besten mit kleinen Bilddateien.
Speichern Sie Ihre Abbilddateien in dem Verzeichnis, das die `inference.py`-Datei enthält. Sie können sie auch in einem Unterverzeichnis dieses Verzeichnisses speichern. Dieses Verzeichnis befindet sich im Lambda-Funktionsbereitstellungspaket, in [Schritt 3: Erstellen Sie eine Inferenz-Lambda-Funktion](#ml-console-dlc-create-lambda) das Sie hochladen.
**Anmerkung**
Sie können auf Wunsch stattdessen eine Kamera auf der Jetson-Karte instrumentieren, um die Quellbilder zu erfassen. Wir empfehlen jedoch nachdrücklich, zunächst mit statischen Bildern zu beginnen.
1. Bearbeiten Sie die Konfiguration der Lambda-Funktion. Folgen Sie dem Verfahren unter [Schritt 4: Fügen Sie die Lambda-Funktion zur Greengrass-Gruppe hinzu](#ml-console-dlc-config-lambda).
**Anmerkung**
Wir empfehlen, dass Sie Ihre Lambda-Funktion ohne Containerisierung ausführen, sofern Ihr Geschäftsszenario dies nicht erfordert. Auf diese Weise können Sie auf die GPU und Kamera Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen. Wenn Sie ohne Containerisierung arbeiten, müssen Sie auch Root-Zugriff auf Ihre AWS IoT Greengrass Lambda-Funktionen gewähren.
1. **Um ohne Containerisierung zu laufen:**
+ Wählen **Sie für Ausführen als**. **Another user ID/group ID** Geben Sie **0** für **UID** ein. Geben Sie für **GUID ein**. **0**
Dadurch kann Ihre Lambda-Funktion als Root ausgeführt werden. Weitere Hinweise zur Ausführung als Root finden Sie unter[Einstellung der Standardzugriffsidentität für Lambda-Funktionen in einer Gruppe](lambda-group-config.md#lambda-access-identity-groupsettings).
**Tipp**
Sie müssen Ihre `config.json` Datei auch aktualisieren, um Root-Zugriff auf Ihre Lambda-Funktion zu gewähren. Informationen zum Verfahren finden Sie unter[Eine Lambda-Funktion als Root ausführen](lambda-group-config.md#lambda-running-as-root).
+ **Wählen Sie für die **Containerisierung von Lambda-Funktionen** die Option Kein Container aus.**
Weitere Hinweise zur Ausführung ohne Containerisierung finden Sie unter. [Überlegungen bei der Wahl der Containerisierung von Lambda-Funktionen](lambda-group-config.md#lambda-containerization-considerations)
+ Erhöhen Sie den Wert für **Timeout** auf 5 Minuten. Dies stellt sicher, dass die Zeit für die Anforderung nicht zu schnell überschritten wird. Nach der Einrichtung dauert es einige Minuten, bis die Inferenz ausgeführt wird.
+ **Wählen Sie für **Pinned** die Option True aus.**
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
1. **Um stattdessen im containerisierten Modus zu starten:**
**Anmerkung**
Wir empfehlen nicht, im containerisierten Modus zu arbeiten, es sei denn, Ihr Geschäftsszenario erfordert dies.
+ Erhöhen Sie den Wert für **Speicherlimit**. Für die Verwendung des bereitgestellten Modells im GPU-Modus verwenden Sie mindestens 2000 MB.
+ Erhöhen Sie den Wert für **Timeout** auf 5 Minuten. Dies stellt sicher, dass die Zeit für die Anforderung nicht zu schnell überschritten wird. Nach der Einrichtung dauert es einige Minuten, bis die Inferenz ausgeführt wird.
+ **Wählen Sie für **Pinned** die Option True aus.**
+ **Wählen Sie unter **Zusätzliche Parameter** für **Lesezugriff auf das Verzeichnis /sys die Option Aktiviert** aus.**
1. Fügen Sie Ihrer Neo-optimierten Modellressource der Gruppe hinzu. Laden Sie die Modellressourcen in das `resnet18`-Verzeichnis des Beispielpakets hoch, das Sie in [Schritt 3: Erstellen Sie eine Inferenz-Lambda-Funktion](#ml-console-dlc-create-lambda) entpackt haben. Dieses Verzeichnis enthält vorkompilierte Modellartefakte für ein mit Resnet-18 geschultes Bildklassifikationsmodell. Folgen Sie dem Verfahren unter [Schritt 5: Fügen Sie der SageMaker Greengrass-Gruppe eine KI-NEO-optimierte Modellressource hinzu](#ml-console-dlc-add-resources) mit den folgenden Updates:
+ Komprimieren Sie die Dateien innerhalb des `resnet18`-Verzeichnisses in eine Datei namens `resnet18.zip`.
+ Geben Sie auf der Seite **Eine maschinelle Lernressource erstellen** für **Ressourcenname** **resnet18\$1model** ein.
+ Hochladen der `resnet18.zip`-Datei
1. **Wenn das Gerät im Containermodus ausgeführt** wird, fügen Sie die erforderlichen lokalen Geräteressourcen hinzu, um Zugriff auf die GPU Ihres Geräts zu gewähren.
**Anmerkung**
Wenn Sie im Modus ohne Container arbeiten, AWS IoT Greengrass können Sie auf die GPU Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen.
1. **Wählen Sie auf der Gruppenkonfigurationsseite die Registerkarte Ressourcen aus.**
1. Wählen Sie im Abschnitt **Lokale Ressourcen** die Option **Lokale Ressource hinzufügen** aus.
1. Definieren Sie die einzelnen Ressourcen:
+ Verwenden Sie für **Resource name (Ressourcenname)** und **Device path (Gerätepfad)** die Werte in der folgenden Tabelle. Erstellen Sie für jede Zeile in der Tabelle genau eine Geräteressource.
+ Wählen Sie in **Resource type (Ressourcentyp)** die Option **Device (Gerät)** aus.
+ Wählen Sie für **Systemgruppenbesitzer- und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe automatisch hinzufügen aus, der die Ressource gehört**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/ml-dlc-console.html)
1. **Wenn es im containerisierten Modus läuft**, fügen Sie die folgende lokale Volume-Ressource hinzu, um Zugriff auf Ihre Gerätekamera zu gewähren. Folgen Sie dem Verfahren unter [Schritt 5: Fügen Sie der SageMaker Greengrass-Gruppe eine KI-NEO-optimierte Modellressource hinzu](#ml-console-dlc-add-resources).
**Anmerkung**
Wenn Sie im Modus ohne Container arbeiten, AWS IoT Greengrass können Sie auf die Kamera Ihres Geräts zugreifen, ohne die Geräteressourcen konfigurieren zu müssen.
+ Wählen Sie für **Resource type (Ressourcentyp)** die Option **Volume** aus.
+ Wählen Sie für **Systemgruppenbesitzer und Dateizugriffsberechtigungen** die Option **Dateisystemberechtigungen der Systemgruppe automatisch hinzufügen aus, der die Ressource gehört**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/greengrass/v1/developerguide/ml-dlc-console.html)
1. Aktualisieren Sie Ihre Gruppenabonnements, um das richtige Verzeichnis zu verwenden. Folgen Sie dem Verfahren unter [Schritt 7: Hinzufügen von Abonnements zur Greengrass-Gruppe](#ml-console-dlc-add-subscription) mit den folgenden Updates:
+ Geben Sie für den ersten Themenfilter **/resnet-18/predictions** ein.
+ Geben Sie für den zweiten Themenfilter **/resnet-18/test** ein.
1. Aktualisieren Sie Ihre Testabonnements, um das richtige Verzeichnis zu verwenden. Folgen Sie dem Verfahren unter [Testen des Inferenzbeispiels](#ml-console-dlc-test-app) mit den folgenden Updates:
+ Wählen Sie für **Abonnements** die Option **Thema abonnieren** aus. Geben Sie für **Abonnementthema** **/resnet-18/predictions** ein.
+ Geben Sie auf der Seite `/resnet-18/predictions` das `/resnet-18/test`-Thema an, zu dem veröffentlicht werden soll.
## Problembehandlung bei AWS IoT Greengrass ML-Inferenz
Wenn der Test nicht erfolgreich ist, können Sie folgende Schritte ausführen, um den Fehler zu beheben. Führen Sie im Raspberry Pi-Terminal die Befehle aus.
### Fehlerprotokolle prüfen
1. Wechseln Sie zum Root-Benutzer und navigieren Sie zum Verzeichnis `log`. Für den Zugriff auf AWS IoT Greengrass Protokolle sind Root-Rechte erforderlich.
```
sudo su
cd /greengrass/ggc/var/log
```
1. Prüfen Sie`runtime.log`, ob Fehler vorliegen.
```
cat system/runtime.log | grep 'ERROR'
```
Sie können auch in Ihrem benutzerdefinierten Lambda-Funktionsprotokoll nach Fehlern suchen:
```
cat user/your-region/your-account-id/lambda-function-name.log | grep 'ERROR'
```
Weitere Informationen finden Sie unter [Fehlerbehebung mit Protokollen](gg-troubleshooting.md#troubleshooting-logs).
### Stellen Sie sicher, dass die Lambda-Funktion erfolgreich bereitgestellt wurde
1. Listet den Inhalt des bereitgestellten Lambda im `/lambda` Verzeichnis auf. Ersetzen Sie die Platzhalterwerte, bevor Sie den Befehl ausführen.
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. Überprüfen Sie, ob das Verzeichnis denselben Inhalt wie das `optimizedImageClassification.zip`-Bereitstellungspaket enthält, das Sie in [Schritt 3: Erstellen Sie eine Inferenz-Lambda-Funktion](#ml-console-dlc-create-lambda) hochgeladen haben.
Stellen Sie sicher, dass sich die `.py`-Dateien und -Abhängigkeiten im Stammverzeichnis befinden.
### Stellen Sie sicher, dass das Inferenzmodell erfolgreich bereitgestellt wird
1. Finden Sie die Prozessidentifikationsnummer (PID) des Lambda-Laufzeitprozesses:
```
ps aux | grep lambda-function-name
```
In der Ausgabe erscheint die PID in der zweiten Spalte der Zeile für den Lambda-Laufzeitprozess.
1. Geben Sie den Lambda-Runtime-Namespace ein. Achten Sie darauf, den *pid* Platzhalterwert zu ersetzen, bevor Sie den Befehl ausführen.
**Anmerkung**
Dieses Verzeichnis und sein Inhalt befinden sich im Lambda-Runtime-Namespace, sodass sie in einem regulären Linux-Namespace nicht sichtbar sind.
```
sudo nsenter -t pid -m /bin/bash
```
1. Listen Sie den Inhalt des lokalen Verzeichnisses, das Sie für die ML-Ressource angegeben haben, auf.
**Anmerkung**
Wenn Ihr ML-Ressourcenpfad anders als `ml_model` lautet, müssen Sie ihn hier ersetzen.
```
cd /ml_model
ls -ls
```
Die Dateien sollten folgendermaßen aussehen:
```
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
```
### Die Lambda-Funktion kann `/dev/dri/renderD128` nicht finden.
Dies kann passieren, wenn OpenCL keine Verbindung zu den benötigten GPU-Geräten herstellen kann. Sie müssen Geräteressourcen für die erforderlichen Geräte für Ihre Lambda-Funktion erstellen.
## Nächste Schritte
Betrachten Sie als Nächstes weitere optimierte Modelle. Informationen finden Sie in der [SageMaker AI Neo-Dokumentation](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).