Avviso di fine del supporto: il 7 ottobre 2026, AWS il supporto per. AWS IoT Greengrass Version 1 Dopo il 7 ottobre 2026, non potrai più accedere alle risorse. AWS IoT Greengrass V1 Per ulteriori informazioni, visita [Migrate](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html) from. AWS IoT Greengrass Version 1
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esecuzione dell'inferenza di Machine Learning
Questa funzionalità è disponibile per AWS IoT Greengrass Core v1.6 o versioni successive.
Con AWS IoT Greengrass, puoi eseguire inferenze di machine learning (ML) all'edge su dati generati localmente utilizzando modelli addestrati sul cloud. In questo modo si beneficia della bassa latenza e dei risparmi sui costi dell'inferenza locale e si sfrutta la potenza del cloud computing per modelli di formazione ed elaborazioni complesse.
Per iniziare eseguendo un'inferenza locale, consulta [Come configurare l'inferenza dell'apprendimento automatico utilizzando Console di gestione AWS](ml-console.md).
## Come funziona AWS IoT Greengrass l'inferenza ML
Puoi addestrare i tuoi modelli di inferenza ovunque, distribuirli localmente come *risorse di machine learning* in un gruppo Greengrass e quindi accedervi dalle funzioni di Greengrass Lambda. Ad esempio, puoi creare e addestrare modelli di deep learning nell'[SageMaker intelligenza artificiale](https://console.aws.amazon.com/sagemaker) e distribuirli nel tuo core Greengrass. Quindi, le funzioni Lambda possono utilizzare i modelli locali per eseguire inferenze sui dispositivi connessi e inviare nuovi dati di addestramento al cloud.
Il diagramma seguente mostra il flusso di lavoro di inferenza AWS IoT Greengrass ML.
![\[Componenti del flusso di lavoro di machine learning e flusso di informazioni tra il dispositivo principale, il AWS IoT Greengrass servizio e i modelli addestrati sul cloud.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-inference/diagram-ml-overview.png)
AWS IoT Greengrass L'inferenza ML semplifica ogni fase del flusso di lavoro ML, tra cui:
+ Sviluppo e distribuzione di prototipi di framework di Machine Learning.
+ Accesso a modelli qualificati per il cloud e distribuzione sui dispositivi core Greengrass.
+ [Creazione di app di inferenza in grado di accedere agli acceleratori hardware (come GPUs e FPGAs) come risorse locali.](access-local-resources.md)
## Risorse di Machine Learning
Le risorse di machine learning rappresentano modelli di inferenza addestrati sul cloud che vengono implementati su un core. AWS IoT Greengrass Per distribuire risorse di machine learning, aggiungete innanzitutto le risorse a un gruppo Greengrass, quindi definite in che modo le funzioni Lambda del gruppo possono accedervi. Durante la distribuzione di gruppo, AWS IoT Greengrass recupera i pacchetti del modello sorgente dal cloud e li estrae nelle directory all'interno dello spazio dei nomi di runtime Lambda. Quindi, le funzioni Greengrass Lambda utilizzano i modelli distribuiti localmente per eseguire l'inferenza.
Per aggiornare un modello distribuito localmente, aggiornare prima il modello di origine (nel cloud) che corrisponde alla risorsa di Machine Learning, quindi distribuire il gruppo. Durante la distribuzione, AWS IoT Greengrass controlla l'origine delle modifiche. Se vengono rilevate modifiche, AWS IoT Greengrass aggiorna il modello locale.
### Origini di modello supportate
AWS IoT Greengrass supporta sorgenti di modelli SageMaker AI e Amazon S3 per risorse di apprendimento automatico.
I seguenti requisiti si applicano alle origini di modello:
+ I bucket S3 che memorizzano le sorgenti del modello SageMaker AI e Amazon S3 non devono essere crittografati utilizzando SSE-C. Per i bucket che utilizzano la crittografia lato server, l'inferenza AWS IoT Greengrass ML attualmente supporta solo le opzioni di crittografia SSE-S3 o SSE-KMS. Per ulteriori informazioni sulle opzioni di crittografia lato server, consulta [Protezione dei dati utilizzando la crittografia lato server nella](https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html) Guida per l'utente di *Amazon Simple Storage Service*.
+ I nomi dei bucket S3 che memorizzano le fonti dei modelli SageMaker AI e Amazon S3 non devono includere periodi (). `.` Per ulteriori informazioni, consulta la regola sull'utilizzo di bucket in stile host virtuale con SSL nelle [Regole per la denominazione dei bucket nella *Amazon* Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html#bucketnamingrules) User Guide.
+ [Il Regione AWS supporto a livello di servizio deve essere disponibile sia per l'IA che per l'intelligenza artificiale. [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)SageMaker ](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html) Attualmente, AWS IoT Greengrass supporta modelli di SageMaker intelligenza artificiale nelle seguenti regioni:
+ Stati Uniti orientali (Ohio)
+ Stati Uniti orientali (Virginia settentrionale)
+ Stati Uniti occidentali (Oregon)
+ Asia Pacifico (Mumbai)
+ Asia Pacifico (Seoul)
+ Asia Pacifico (Singapore)
+ Asia Pacifico (Sydney)
+ Asia Pacifico (Tokyo)
+ Europa (Francoforte)
+ Europa (Irlanda)
+ Europa (Londra)
+ AWS IoT Greengrass deve avere l'`read`autorizzazione alla fonte del modello, come descritto nelle sezioni seguenti.
**SageMaker INTELLIGENZA ARTIFICIALE**
AWS IoT Greengrass supporta modelli che vengono salvati come lavori di formazione sull' SageMaker intelligenza artificiale. SageMaker L'intelligenza artificiale è un servizio di machine learning completamente gestito che puoi utilizzare per creare e addestrare modelli utilizzando algoritmi integrati o personalizzati. Per ulteriori informazioni, consulta [Cos'è l' SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)? nella *Guida per sviluppatori di SageMaker intelligenza artificiale*.
Se hai configurato il tuo ambiente di SageMaker intelligenza artificiale [creando un bucket](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-config-permissions.html) il cui nome contiene`sagemaker`, allora AWS IoT Greengrass disponi delle autorizzazioni sufficienti per accedere ai tuoi lavori di formazione sull' SageMaker intelligenza artificiale. La policy gestita `AWSGreengrassResourceAccessRolePolicy` consente di accedere ai bucket il cui nome contiene la stringa `sagemaker`. Questa policy è collegata al [ruolo di servizio Greengrass](service-role.md).
Altrimenti, devi concedere l' AWS IoT Greengrass `read`autorizzazione al bucket in cui è archiviato il tuo lavoro di formazione. Per effettuare questa operazione, inserisci la seguente policy inline nel ruolo di servizio. Puoi elencare più ARNs bucket.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
**Amazon S3**
AWS IoT Greengrass supporta modelli archiviati in Amazon S3 come file `tar.gz` o`.zip`.
Per consentire l'accesso AWS IoT Greengrass ai modelli archiviati nei bucket Amazon S3, devi concedere l' AWS IoT Greengrass `read`autorizzazione ad accedere ai bucket effettuando **una delle** seguenti operazioni:
+ Archivia il modello in un bucket il cui nome contiene `greengrass`.
La policy gestita `AWSGreengrassResourceAccessRolePolicy` consente di accedere ai bucket il cui nome contiene la stringa `greengrass`. Questa policy è collegata al [ruolo di servizio Greengrass](service-role.md).
+ Incorpora una policy inline nel ruolo di servizio Greengrass.
Se il nome del bucket non contiene `greengrass`, aggiungi le seguenti policy inline al ruolo di servizio. Puoi elencare più bucket. ARNs
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
------
Per ulteriori informazioni, consulta [Incorporare le politiche in linea](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console) nella Guida per l'utente *IAM*.
## Requisiti
I seguenti requisiti si applicano alla creazione e all'utilizzo di risorse di Machine Learning:
+ È necessario utilizzare AWS IoT Greengrass Core v1.6 o versione successiva.
+ Le funzioni Lambda definite dall'utente possono `read` eseguire `read and write` operazioni sulla risorsa. Le autorizzazioni per altre operazioni non sono disponibili. La modalità di containerizzazione delle funzioni Lambda affiliate determina il modo in cui si impostano le autorizzazioni di accesso. Per ulteriori informazioni, consulta [Accedi alle risorse di machine learning dalle funzioni Lambda](access-ml-resources.md).
+ È necessario fornire il percorso completo della risorsa sul sistema operativo del dispositivo core.
+ Un nome o ID di risorsa deve avere un massimo di 128 caratteri e deve utilizzare il modello `[a-zA-Z0-9:_-]+`.
## Runtime e librerie per inferenza ML
È possibile utilizzare i seguenti runtime e librerie ML con. AWS IoT Greengrass
+ [Runtime di apprendimento approfondito di Amazon SageMaker Neo](#dlc-optimize-info)
+ Apache MXNet
+ TensorFlow
Questi runtime e librerie possono essere installati su piattaforme NVIDIA Jetson TX2, Intel Atom e Raspberry Pi. Per informazioni di download, consulta [Runtime e librerie di Machine Learning supportati](what-is-gg.md#ml-runtimes-libs). Puoi installarli direttamente sul dispositivo principale.
Assicurati di leggere le seguenti informazioni sulla compatibilità e sulle limitazioni.
### SageMaker Runtime di deep learning AI Neo
Puoi utilizzare il runtime di deep learning SageMaker AI Neo per eseguire inferenze con modelli di machine learning ottimizzati sui tuoi AWS IoT Greengrass dispositivi. Questi modelli sono ottimizzati utilizzando il compilatore di deep learning SageMaker AI Neo per migliorare la velocità di previsione dell'inferenza dell'apprendimento automatico. Per ulteriori informazioni sull'ottimizzazione dei modelli nell' SageMaker intelligenza artificiale, consulta la documentazione di [SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
**Nota**
Attualmente, puoi ottimizzare i modelli di machine learning utilizzando il compilatore di deep learning Neo solo in specifiche regioni di Amazon Web Services. Tuttavia, puoi utilizzare il runtime di deep learning Neo con modelli ottimizzati in ognuna delle Regione AWS quali è supportato il AWS IoT Greengrass core. Per informazioni, consulta [Come configurare l'inferenza Machine Learning ottimizzata](ml-dlc-console.md).
### MXNet controllo delle versioni
Attualmente Apache MXNet non garantisce la compatibilità con le versioni future, quindi i modelli addestrati utilizzando versioni successive del framework potrebbero non funzionare correttamente nelle versioni precedenti del framework. Per evitare conflitti tra le fasi di formazione del modello e di gestione del modello e per fornire un' end-to-endesperienza coerente, utilizzate la stessa versione del MXNet framework in entrambe le fasi.
### MXNet su Raspberry Pi
Le funzioni Greengrass Lambda che accedono ai MXNet modelli locali devono impostare la seguente variabile di ambiente:
```
MXNET_ENGINE_TYPE=NativeEngine
```
È possibile impostare la variabile d'ambiente nel codice funzione o aggiungerla alla configurazione specifica del gruppo della funzione. Per un esempio in cui viene aggiunta come impostazione di configurazione, vedi questa [fase](ml-console.md#ml-console-config-lambda).
**Nota**
Per un uso generale del MXNet framework, come l'esecuzione di un esempio di codice di terze parti, la variabile di ambiente deve essere configurata su Raspberry Pi.
### TensorFlow limitazioni relative al servizio dei modelli su Raspberry Pi
I seguenti consigli per migliorare i risultati di inferenza si basano sui nostri test con le librerie Arm TensorFlow a 32 bit sulla piattaforma Raspberry Pi. Queste raccomandazioni sono destinate a utenti esperti solo per riferimento, senza garanzie di alcun tipo.
+ Modelli che sono addestrati utilizzando il formato [Checkpoint](https://www.tensorflow.org/guide/checkpoint) devono essere "congelati" nel formato del buffer di protocollo prima di essere messi a disposizione. Per un esempio, consulta la libreria di modelli di classificazione delle [TensorFlowimmagini -Slim.](https://github.com/tensorflow/models/tree/master/research/slim)
+ Non utilizzare le librerie TF-Estimator e TF-Slim in codice di training o di inferenza. Utilizzare invece il pattern di caricamento del modello di file `.pb` che viene mostrato nell'esempio seguente.
```
graph = tf.Graph()
graph_def = tf.GraphDef()
graph_def.ParseFromString(pb_file.read())
with graph.as_default():
tf.import_graph_def(graph_def)
```
**Nota**
Per ulteriori informazioni sulle piattaforme supportate per TensorFlow, vedete [Installazione TensorFlow](https://www.tensorflow.org/install/#installing_from_sources) nella TensorFlow documentazione.
# Accedi alle risorse di machine learning dalle funzioni Lambda
Le funzioni Lambda definite dall'utente possono accedere alle risorse di machine learning per eseguire inferenze locali sul core. AWS IoT Greengrass Una risorsa di machine learning è costituita dal modello con training e da altri artefatti che vengono scaricati nel dispositivo core.
Per consentire a una funzione Lambda di accedere a una risorsa di machine learning centrale, è necessario collegare la risorsa alla funzione Lambda e definire le autorizzazioni di accesso. La [modalità di containerizzazione](lambda-group-config.md#lambda-function-containerization) della funzione Lambda affiliata (o *allegata)* determina come eseguire questa operazione.
## Autorizzazioni di accesso per risorse di Machine Learning
A partire da AWS IoT Greengrass Core v1.10.0, puoi definire il proprietario della risorsa per una risorsa di machine learning. Il proprietario della risorsa rappresenta il gruppo del sistema operativo e le autorizzazioni AWS IoT Greengrass utilizzati per scaricare gli artefatti delle risorse. Se il proprietario di una risorsa non è definito, gli artefatti della risorsa scaricati sono accessibili solo al root.
+ Se le funzioni Lambda non containerizzate accedono a una risorsa di machine learning, è necessario definire un proprietario della risorsa perché non esiste alcun controllo delle autorizzazioni da parte del contenitore. Le funzioni Lambda non containerizzate possono ereditare le autorizzazioni del proprietario della risorsa e utilizzarle per accedere alla risorsa.
+ Se solo le funzioni Lambda containerizzate accedono alla risorsa, ti consigliamo di utilizzare le autorizzazioni a livello di funzione invece di definire un proprietario della risorsa.
### Proprietà del proprietario delle risorse
Un proprietario delle risorse specifica un proprietario del gruppo e le autorizzazioni del proprietario del gruppo.
**Proprietario del gruppo**. L'ID del gruppo (GID) di un gruppo OS Linux esistente sul dispositivo core. Le autorizzazioni del gruppo vengono aggiunte al processo Lambda. In particolare, il GID viene aggiunto al gruppo supplementare IDs della funzione Lambda.
Se una funzione Lambda del gruppo Greengrass è configurata per essere [eseguita come](lambda-group-config.md#lambda-access-identity) lo stesso gruppo di sistemi operativi del proprietario della risorsa per una risorsa di machine learning, la risorsa deve essere collegata alla funzione Lambda. In caso contrario, la distribuzione non riesce perché questa configurazione fornisce autorizzazioni implicite che la funzione Lambda può utilizzare per accedere alla risorsa senza autorizzazione. AWS IoT Greengrass Il controllo di convalida della distribuzione viene saltato se la funzione Lambda viene eseguita come root (UID=0).
Ti consigliamo di utilizzare un gruppo di sistemi operativi non utilizzato da altre risorse, funzioni Lambda o file sul core Greengrass. L'utilizzo di un gruppo di sistemi operativi condiviso offre alle funzioni Lambda collegate più autorizzazioni di accesso di quelle necessarie. Se si utilizza un gruppo di sistemi operativi condiviso, è necessario allegare anche una funzione Lambda associata a tutte le risorse di machine learning che utilizzano il gruppo di sistemi operativi condiviso. In caso contrario, la distribuzione non riesce.
**Autorizzazioni del proprietario del gruppo**. L'autorizzazione di sola lettura o lettura e scrittura da aggiungere al processo Lambda.
Le funzioni Lambda non containerizzate devono ereditare queste autorizzazioni di accesso alla risorsa. Le funzioni Lambda containerizzate possono ereditare queste autorizzazioni a livello di risorsa o definire autorizzazioni a livello di funzione. Se definiscono autorizzazioni a livello di funzione, le autorizzazioni devono essere identiche o più restrittive rispetto alle autorizzazioni a livello di risorsa.
Nella tabella seguente vengono illustrate le configurazioni di autorizzazione di accesso supportate.
------
#### [ GGC v1.10 or later ]
| Proprietà | Se solo le funzioni Lambda containerizzate accedono alla risorsa | Se qualche funzione Lambda non containerizzata accede alla risorsa |
| --- |--- |--- |
| **Proprietà a livello di funzione** |
| --- |
| Autorizzazioni (lettura/scrittura) | Obbligatorie a meno che la risorsa non definisca un proprietario delle risorse. Se viene definito un proprietario delle risorse, le autorizzazioni a livello di funzione devono essere identiche o più restrittive rispetto alle autorizzazioni del proprietario delle risorse. Se solo le funzioni Lambda containerizzate accedono alla risorsa, ti consigliamo di non definire un proprietario della risorsa. | **Funzioni Lambda non containerizzate:** Non supportato. Le funzioni Lambda non containerizzate devono ereditare le autorizzazioni a livello di risorsa. **Funzioni Lambda containerizzate:** Facoltativo, ma devono essere identiche o più restrittive rispetto alle autorizzazioni a livello di risorse. |
| **Proprietà a livello di risorse** |
| --- |
| Proprietario delle risorse | Facoltativo (non consigliato). | Obbligatorio. |
| Autorizzazioni (lettura/scrittura) | Facoltativo (non consigliato). | Obbligatorio. |
------
#### [ GGC v1.9 or earlier ]
| Proprietà | Se solo le funzioni Lambda containerizzate accedono alla risorsa | Se qualche funzione Lambda non containerizzata accede alla risorsa |
| --- |--- |--- |
| **Proprietà a livello di funzione** |
| --- |
| Autorizzazioni (lettura/scrittura) | Obbligatorio. | Non supportato. |
| **Proprietà a livello di risorse** |
| --- |
| Proprietario delle risorse | Non supportato. | Non supportato. |
| Autorizzazioni (lettura/scrittura) | Non supportato. | Non supportato. |
------
**Nota**
Quando si utilizza l' AWS IoT Greengrass API per configurare le funzioni e le risorse Lambda, è richiesta anche la `ResourceId` proprietà a livello di funzione. La `ResourceId` proprietà collega la risorsa di machine learning alla funzione Lambda.
## Definizione delle autorizzazioni di accesso per le funzioni Lambda (console)
Nella AWS IoT console, definisci le autorizzazioni di accesso quando configuri una risorsa di machine learning o ne alleghi una a una funzione Lambda.
**Funzioni Lambda containerizzate**
Se alla risorsa di machine learning sono collegate solo funzioni Lambda containerizzate:
+ Scegli **Nessun gruppo di sistema** come proprietario della risorsa di machine learning. Questa è l'impostazione consigliata quando solo le funzioni Lambda containerizzate accedono alla risorsa di machine learning. Altrimenti, potresti concedere alle funzioni Lambda allegate più autorizzazioni di accesso di quelle necessarie.
Funzioni **Lambda non containerizzate** (richiede GGC v1.10 o versione successiva)
Se alla risorsa di machine learning sono collegate funzioni Lambda non containerizzate:
+ Specificate il **System group ID (GID)** da utilizzare come proprietario della risorsa di machine learning. Scegli **Specificare il gruppo di sistema e le autorizzazioni** e inserisci il GID. È possibile utilizzare il `getent group` comando sul dispositivo principale per cercare l'ID di un gruppo di sistema.
+ Scegli Accesso in **sola lettura o Accesso** in **lettura e scrittura per le autorizzazioni** del **gruppo di sistema**.
## Definizione delle autorizzazioni di accesso per le funzioni Lambda (API)
Nell' AWS IoT Greengrass API, definisci le autorizzazioni per le risorse di machine learning nella `ResourceAccessPolicy` proprietà della funzione Lambda o nella proprietà `OwnerSetting` della risorsa.
**Funzioni Lambda containerizzate**
Se alla risorsa di machine learning sono collegate solo funzioni Lambda containerizzate:
+ Per le funzioni Lambda containerizzate, definisci le autorizzazioni di accesso nella proprietà della `Permission` proprietà. `ResourceAccessPolicies` Esempio:
```
"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
}
}
]
```
+ Per le risorse di machine learning, ometti la proprietà `OwnerSetting`. Esempio:
```
"Resources": [
{
"Id": "my-resource-id",
"Name": "my-resource-name",
"ResourceDataContainer": {
"S3MachineLearningModelResourceData": {
"DestinationPath": "/local-destination-path",
"S3Uri": "s3://uri-to-resource-package"
}
}
}
]
```
Questa è la configurazione consigliata quando solo le funzioni Lambda containerizzate accedono alla risorsa di machine learning. Altrimenti, potresti concedere alle funzioni Lambda allegate più autorizzazioni di accesso di quelle necessarie.
Funzioni **Lambda non containerizzate** (richiede GGC v1.10 o versione successiva)
Se alla risorsa di machine learning sono collegate funzioni Lambda non containerizzate:
+ Per le funzioni Lambda non containerizzate, ometti la proprietà in. `Permission` `ResourceAccessPolicies` Questa configurazione è obbligatoria e consente alla funzione di ereditare l'autorizzazione a livello di risorsa. Esempio:
```
"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
}
}
]
```
+ Per le funzioni Lambda containerizzate che accedono anche alla risorsa di machine learning, ometti la `Permission` proprietà `ResourceAccessPolicies` o definisci un'autorizzazione uguale o più restrittiva dell'autorizzazione a livello di risorsa. Esempio:
```
"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
}
}
]
```
+ Per le risorse di machine learning, definisci la proprietà `OwnerSetting`, inclusi il figlio `GroupOwner` e le proprietà `GroupPermission`. Esempio:
```
"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"
}
}
}
}
]
```
## Accesso alle risorse di machine learning dal codice della funzione Lambda
Le funzioni Lambda definite dall'utente utilizzano interfacce del sistema operativo specifiche della piattaforma per accedere alle risorse di machine learning su un dispositivo principale.
------
#### [ GGC v1.10 or later ]
Per le funzioni Lambda containerizzate, la risorsa è montata all'interno del contenitore Greengrass e disponibile nel percorso di destinazione locale definito per la risorsa. Per le funzioni Lambda non containerizzate, la risorsa è collegata simbolicamente a una directory di lavoro specifica di Lambda e passata alla variabile di ambiente nel processo Lambda. `AWS_GG_RESOURCE_PREFIX`
Per ottenere il percorso degli artefatti scaricati di una risorsa di machine learning, le funzioni Lambda aggiungono la variabile di `AWS_GG_RESOURCE_PREFIX` ambiente al percorso di destinazione locale definito per la risorsa. Per le funzioni Lambda containerizzate, il valore restituito è una singola barra (). `/`
```
resourcePath = os.getenv("AWS_GG_RESOURCE_PREFIX") + "/destination-path"
with open(resourcePath, 'r') as f:
# load_model(f)
```
------
#### [ GGC v1.9 or earlier ]
Gli artefatti scaricati di una risorsa di machine learning si trovano nel percorso di destinazione locale definito per la risorsa. Solo le funzioni Lambda containerizzate possono accedere alle risorse di machine learning in AWS IoT Greengrass Core v1.9 e versioni precedenti.
```
resourcePath = "/local-destination-path"
with open(resourcePath, 'r') as f:
# load_model(f)
```
------
L'implementazione del caricamento del modello dipende dalla libreria ML.
## Risoluzione dei problemi
Utilizza le informazioni seguenti per risolvere problemi relativi all'accesso alle risorse di machine learning.
**Topics**
+ [MLModelProprietario non valido: GroupOwnerSetting è fornito nella risorsa del modello ML, ma non è presente o non è presente GroupOwner GroupPermission](#nocontainer-lambda-invalid-ml-model-owner)
+ [NoContainer la funzione non può configurare l'autorizzazione quando si collegano risorse di Machine Learning. si riferisce alla risorsa Machine Learning con autorizzazione nella politica di accesso alle risorse.](#nocontainer-lambda-invalid-resource-access-policy)
+ [La funzione si riferisce alla risorsa di Machine Learning con autorizzazione mancante in entrambe ResourceAccessPolicy le risorse OwnerSetting.](#nocontainer-lambda-missing-access-permission)
+ [La funzione si riferisce alla risorsa Machine Learning con autorizzazione\$1 "rw\$1», mentre l'impostazione del proprietario della risorsa consente GroupPermission solo\$1 "ro\$1».](#container-lambda-invalid-rw-permissions)
+ [NoContainer La funzione si riferisce alle risorse del percorso di destinazione annidato.](#nocontainer-lambda-nested-destination-path)
+ [Lambda ottiene l'accesso alla risorsa condividendo lo stesso ID del proprietario del gruppo](#lambda-runas-and-resource-owner)
### MLModelProprietario non valido: GroupOwnerSetting è fornito nella risorsa del modello ML, ma non è presente o non è presente GroupOwner GroupPermission
**Soluzione:** viene visualizzato questo errore se una risorsa di machine learning contiene l'[ResourceDownloadOwnerSetting](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resourcedownloadownersetting.html)oggetto ma il requisito `GroupOwner` o la `GroupPermission` proprietà non sono definiti. Per risolvere questo problema, definisci la proprietà mancante.
### NoContainer la funzione non può configurare l'autorizzazione quando si collegano risorse di Machine Learning. si riferisce alla risorsa Machine Learning con autorizzazione nella politica di accesso alle risorse.
**Soluzione: viene** visualizzato questo errore se una funzione Lambda non containerizzata specifica autorizzazioni a livello di funzione per una risorsa di machine learning. Le funzioni non containerizzate devono ereditare le autorizzazioni dalle autorizzazioni del proprietario della risorsa definite nella risorsa di machine learning. Per risolvere questo problema, scegli di [ereditare le autorizzazioni del proprietario della risorsa](#non-container-config-console) (console) o [rimuovere le autorizzazioni dalla politica di accesso alle risorse (API) della funzione Lambda](#non-container-config-api).
### La funzione si riferisce alla risorsa di Machine Learning con autorizzazione mancante in entrambe ResourceAccessPolicy le risorse OwnerSetting.
**Soluzione:** viene visualizzato questo errore se le autorizzazioni per la risorsa di machine learning non sono configurate per la funzione Lambda o la risorsa allegata. Per risolvere questo problema, configura le autorizzazioni nella [ResourceAccessPolicy](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resourceaccesspolicy.html)proprietà per la funzione Lambda o nella proprietà per [OwnerSetting](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-ownersetting.html)la risorsa.
### La funzione si riferisce alla risorsa Machine Learning con autorizzazione\$1 "rw\$1», mentre l'impostazione del proprietario della risorsa consente GroupPermission solo\$1 "ro\$1».
**Soluzione:** viene visualizzato questo errore se le autorizzazioni di accesso definite per la funzione Lambda allegata superano le autorizzazioni del proprietario della risorsa definite per la risorsa di machine learning. Per risolvere questo problema, imposta autorizzazioni più restrittive per la funzione Lambda o autorizzazioni meno restrittive per il proprietario della risorsa.
### NoContainer La funzione si riferisce alle risorse del percorso di destinazione annidato.
**Soluzione:** viene visualizzato questo errore se più risorse di machine learning collegate a una funzione Lambda non containerizzata utilizzano lo stesso percorso di destinazione o un percorso di destinazione annidato. Per risolvere questo problema, specifica percorsi di destinazione separati per le risorse.
### Lambda ottiene l'accesso alla risorsa condividendo lo stesso ID del proprietario del gruppo
**Soluzione:** viene visualizzato questo errore `runtime.log` se viene specificato lo stesso gruppo di sistema operativo come identità [Esegui come](lambda-group-config.md#lambda-access-identity) identità della funzione Lambda e [proprietario della risorsa](#ml-resource-owner) per una risorsa di machine learning, ma la risorsa non è associata alla funzione Lambda. Questa configurazione fornisce alla funzione Lambda autorizzazioni implicite che può utilizzare per accedere alla risorsa senza autorizzazione. AWS IoT Greengrass
Per risolvere questo problema, usa un gruppo di sistemi operativi diverso per una delle proprietà o collega la risorsa di machine learning alla funzione Lambda.
## Consulta anche
+ [Esecuzione dell'inferenza di Machine Learning](ml-inference.md)
+ [Come configurare l'inferenza dell'apprendimento automatico utilizzando Console di gestione AWS](ml-console.md)
+ [Come configurare l'inferenza ottimizzata dell'apprendimento automatico utilizzando Console di gestione AWS](ml-dlc-console.md)
+ [AWS IoT Greengrass Version 1 Documentazione di riferimento delle API](https://docs.aws.amazon.com/greengrass/v1/apireference/api-doc.html)
# Come configurare l'inferenza dell'apprendimento automatico utilizzando Console di gestione AWS
Per seguire i passaggi di questo tutorial, è necessario AWS IoT Greengrass Core v1.10 o versione successiva.
Puoi eseguire l'inferenza di Machine Learning (ML) in locale su un dispositivo core Greengrass utilizzando i dati generati localmente. Per informazioni, inclusi i requisiti e i vincoli, consulta [Esecuzione dell'inferenza di Machine Learning](ml-inference.md).
Questo tutorial descrive come utilizzare Console di gestione AWS per configurare un gruppo Greengrass per eseguire un'app di inferenza Lambda che riconosce le immagini da una fotocamera localmente, senza inviare dati al cloud. L'app di inferenza accede al modulo fotocamera su un Raspberry Pi ed esegue l'inferenza utilizzando il modello open source. [SqueezeNet](https://github.com/DeepScale/SqueezeNet)
Il tutorial include le seguenti fasi di alto livello:
1. [Configurare il dispositivo Raspberry Pi](#config-raspberry-pi)
1. [Installa il MXNet framework](#install-mxnet)
1. [Crea un pacchetto di modelli](#package-ml-model)
1. [Creare e pubblicare una funzione Lambda](#ml-console-create-lambda)
1. [Aggiungere la funzione Lambda al gruppo](#ml-console-config-lambda)
1. [Aggiunta di risorse al gruppo](#ml-console-add-resources)
1. [Aggiunta di una sottoscrizione al gruppo](#ml-console-add-subscription)
1. [Distribuzione del gruppo.](#ml-console-deploy-group)
1. [Esecuzione del test dell'app](#ml-console-test-app)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Raspberry Pi 4 Model B o Raspberry Pi 3 Model B/B\$1, configurato e configurato per l'uso con. AWS IoT Greengrass Per configurare Raspberry Pi con AWS IoT Greengrass, eseguire lo script di [configurazione del dispositivo Greengrass](quick-start.md) o assicurarsi di aver completato il [modulo 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) e il [modulo 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) di [Iniziare con AWS IoT Greengrass](gg-gs.md).
**Nota**
Il Raspberry Pi potrebbe richiedere un [alimentatore](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/) da 2,5 A per eseguire i framework di deep learning generalmente utilizzati per la classificazione delle immagini. Un alimentatore con una potenza nominale inferiore potrebbe causare il riavvio del dispositivo.
+ [Modulo della telecamera Raspberry Pi V2 da 8 Megapixel, 1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Per informazioni su come configurare la fotocamera, consulta [Collegamento della fotocamera](https://www.raspberrypi.org/documentation/usage/camera/) nella documentazione di Raspberry Pi.
+ Un gruppo e un core Greengrass. Per informazioni su come creare un gruppo o un nucleo Greengrass, vedere. [Iniziare con AWS IoT Greengrass](gg-gs.md)
**Nota**
Questo tutorial utilizza un Raspberry Pi, ma AWS IoT Greengrass supporta altre piattaforme, come [Intel Atom](#atom-lambda-config) e [NVIDIA](#jetson-lambda-config) Jetson. TX2 Nell'esempio di Jetson TX2, è possibile utilizzare immagini statiche anziché immagini trasmesse in streaming da una fotocamera. Se si utilizza l' TX2 esempio Jetson, potrebbe essere necessario installare Python 3.6 anziché Python 3.7. Per informazioni sulla configurazione del dispositivo in modo da poter installare il software Core, consulta. AWS IoT Greengrass [Configurazione di altri dispositivi](setup-filter.other.md)
Per le piattaforme di terze parti che AWS IoT Greengrass non supportano, è necessario eseguire la funzione Lambda in modalità non containerizzata. Per l'esecuzione in modalità non containerizzata, è necessario eseguire la funzione Lambda come utente root. Per ulteriori informazioni, consultare [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations) e [Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
## Fase 1: Configurare il dispositivo Raspberry Pi
In questa fase, verranno installati gli aggiornamenti del sistema operativo Raspbian, il software del modulo della telecamera e le dipendenze Python e verrà abilitata l'interfaccia della telecamera.
Esegui i seguenti comandi nel terminale Raspberry Pi.
1. Installare gli aggiornamenti in Raspbian.
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. Installare l'interfaccia `picamera` per il modulo della telecamera e le altre librerie Python necessarie per questo tutorial.
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
Convalidare l'installazione:
+ Assicurati che l'installazione di Python 3.7 includa pip.
```
python3 -m pip
```
Se pip non è installato, scaricarlo dal [sito Web pip](https://pip.pypa.io/en/stable/installing/) ed eseguire il comando seguente.
```
python3 get-pip.py
```
+ Assicurati che la versione Python sia 3.7 o superiore.
```
python3 --version
```
Se l'output elenca una versione precedente, eseguire il comando seguente.
```
sudo apt-get install -y python3.7-dev
```
+ Assicurati che Setuptools e Picamera siano stati installati correttamente.
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Se l'output non contiene errori, la convalida ha esito positivo.
**Nota**
Se l'eseguibile Python installato sul dispositivo è `python3.7`, utilizzare `python3.7` invece di `python3` per i comandi in questo tutorial. Assicurati che l'installazione di pip sia mappata alla versione `python3.7` o `python3` corretta per evitare errori di dipendenza.
1. Riavvia il dispositivo Raspberry Pi.
```
sudo reboot
```
1. Apri lo strumento di configurazione di Raspberry Pi.
```
sudo raspi-config
```
1. Utilizza i tasti freccia per aprire **Interfacing Options (Opzioni di interfaccia)** e abilita l'interfaccia della telecamera. Se richiesto, consenti il riavvio del dispositivo.
1. Utilizza il seguente comando per eseguire il test della configurazione della telecamera.
```
raspistill -v -o test.jpg
```
Viene visualizzata una finestra di anteprima sul dispositivo Raspberry Pi, viene salvata un'immagine denominata `test.jpg` nella directory corrente e vengono visualizzati informazioni sulla telecamera nel terminale Raspberry Pi.
## Fase 2: Installare il framework MXNet
In questo passaggio, installa MXNet le librerie sul tuo Raspberry Pi.
1. Accedere al Raspberry Pi da remoto.
```
ssh pi@your-device-ip-address
```
1. Apri la MXNet documentazione, apri [Installazione MXNet](https://mxnet.apache.org/get_started/?) e segui le istruzioni per l'installazione MXNet sul dispositivo.
**Nota**
Ti consigliamo di installare la versione 1.5.0 e di compilarlo MXNet dal codice sorgente per questo tutorial per evitare conflitti tra dispositivi.
1. Dopo l'installazione MXNet, convalida la seguente configurazione:
+ Assicurati che l'account `ggc_user` di sistema possa utilizzare il MXNet framework.
```
sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
+ Assicurati che NumPy sia installato.
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## Fase 3: Creare un pacchetto MXNet modello
In questo passaggio, crea un pacchetto modello che contenga un MXNet modello preaddestrato di esempio da caricare su Amazon Simple Storage Service (Amazon S3). AWS IoT Greengrass può utilizzare un pacchetto modello di Amazon S3, a condizione che utilizzi il formato tar.gz o zip.
1. Sul tuo computer, scarica l' MXNet esempio per Raspberry Pi da. [Esempi di Machine Learning](what-is-gg.md#gg-ml-samples)
1. Decomprimere il file `mxnet-py3-armv7l.tar.gz` scaricato.
1. Passa alla directory `squeezenet`.
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/models/squeezenet
```
Il file `squeezenet.zip` in questa directory è il pacchetto del modello. Contiene elementi del modello SqueezeNet open source per un modello di classificazione delle immagini. Successivamente, carichi questo pacchetto modello su Amazon S3.
## Fase 4: Creare e pubblicare una funzione Lambda
In questo passaggio, crea un pacchetto di distribuzione della funzione Lambda e una funzione Lambda. Quindi pubblicare una versione della funzione e creare un alias.
Innanzitutto, crea il pacchetto di distribuzione della funzione Lambda.
1. Nel computer, passare alla directory `examples` nel pacchetto di esempio decompresso in [Fase 3: Creare un pacchetto MXNet modello](#package-ml-model).
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/examples
```
La directory `examples` contiene il codice di funzione e le dipendenze.
+ `greengrassObjectClassification.py` è il codice di inferenza utilizzato in questo tutorial. È possibile utilizzare questo codice come modello per creare la propria funzione di inferenza.
+ `greengrasssdk`è la versione 1.5.0 del AWS IoT Greengrass Core SDK for Python.
**Nota**
Se è disponibile una nuova versione, è possibile scaricarla e aggiornare la versione dell'SDK nel pacchetto di distribuzione. Per ulteriori informazioni, consulta [AWS IoT Greengrass Core SDK for GitHub Python on](https://github.com/aws/aws-greengrass-core-sdk-python/).
1. Comprimere il contenuto della directory `examples` in un file denominato `greengrassObjectClassification.zip`. Questo è il pacchetto di distribuzione.
```
zip -r greengrassObjectClassification.zip .
```
**Nota**
Assicurarsi inoltre che i file `.py` e le dipendenze si trovino nella radice della directory.
Quindi, crea la funzione Lambda.
1. Dalla AWS IoT console, scegli **Funzioni** e **Crea funzione**.
1. Scegli **Author da zero** e usa i seguenti valori per creare la tua funzione:
+ Nel campo **Function name (Nome funzione)**, immettere **greengrassObjectClassification**.
+ In **Runtime**, scegliere **Python 3.7**.
Per **le autorizzazioni**, mantieni l'impostazione predefinita. Questo crea un ruolo di esecuzione che concede le autorizzazioni Lambda di base. Questo ruolo non viene utilizzato da. AWS IoT Greengrass
1. Scegli **Crea funzione**.
Ora carica il pacchetto di distribuzione della funzione Lambda e registra il gestore.
1. Scegli la tua funzione Lambda e carica il pacchetto di implementazione della funzione Lambda.
1. Nella scheda **Codice**, in **Codice sorgente**, scegli **Carica** da. Dal menu a discesa, scegli un **file.zip.**
![\[Il menu a discesa Carica da con il file.zip evidenziato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. Scegli **Carica**, quindi scegli il pacchetto di `greengrassObjectClassification.zip` distribuzione. Poi, scegli **Salva**.
1. Nella scheda **Codice** della funzione, in **Impostazioni di runtime**, scegliete **Modifica**, quindi immettete i seguenti valori.
+ In **Runtime**, scegliere **Python 3.7**.
+ Per **Gestore**, inserisci **greengrassObjectClassification.function\$1handler**.
Scegli **Save** (Salva).
Successivamente, pubblica la prima versione della tua funzione Lambda. Quindi, creare un [alias per la versione](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html).
**Nota**
I gruppi Greengrass possono fare riferimento a una funzione Lambda tramite alias (consigliato) o per versione. L'utilizzo di un alias semplifica la gestione degli aggiornamenti del codice perché non è necessario modificare la tabella di sottoscrizione o la definizione del gruppo quando il codice della funzione viene aggiornato. Invece, è sufficiente indirizzare l'alias alla nuova versione della funzione.
1. Nel menu **Actions (Operazioni)**, seleziona **Publish new version (Pubblica nuova versione)**.
![\[L'opzione Publish new version (Pubblica nuova versione) nel menu Actions (Azioni).\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-inference/lambda-publish-version.png)
1. Per **Version description (Descrizione versione)**, immettere **First version**, quindi scegliere **Publish (Pubblica)**.
1. Nella pagina di configurazione **greengrassObjectClassification: 1**, dal menu **Azioni**, scegli **Crea alias**.
![\[L'opzione Create alias (Crea alias) nel menu Actions (Azioni).\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-inference/lambda-create-alias.png)
1. Nella pagina **Create a new alias (Crea un nuovo alias)**, utilizza i seguenti valori:
+ In **Nome**, inserisci **mlTest**.
+ Per **Version (Versione)**, immettere **1**.
**Nota**
AWS IoT Greengrass **non supporta gli alias Lambda per le versioni \$1LATEST.**
1. Scegli **Save** (Salva).
Ora aggiungete la funzione Lambda al vostro gruppo Greengrass.
## Fase 5: Aggiungere la funzione Lambda al gruppo Greengrass
In questo passaggio, aggiungi la funzione Lambda al gruppo e quindi configura il ciclo di vita e le variabili di ambiente.
Innanzitutto, aggiungi la funzione Lambda al tuo gruppo Greengrass.
1. Nel riquadro di navigazione della AWS IoT console, in **Gestione**, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1**).
1. Dalla pagina di configurazione del gruppo, scegli la scheda **Funzioni Lambda**.
1. **Nella sezione **Funzioni My Lambda**, scegli Aggiungi.**
1. Per la **funzione Lambda, scegli**. **greengrassObjectClassification**
1. **Per la **versione della funzione Lambda**, scegliete Alias:MLTest.**
Quindi, configura il ciclo di vita e le variabili di ambiente della funzione Lambda.
1. Nella sezione di **configurazione della funzione Lambda**, apporta i seguenti aggiornamenti.
**Nota**
Ti consigliamo di eseguire la funzione Lambda senza containerizzazione a meno che il tuo business case non lo richieda. Ciò consente l'accesso alla GPU e alla fotocamera del dispositivo senza configurare le risorse del dispositivo. Se esegui senza containerizzazione, devi anche concedere l'accesso root alle tue funzioni Lambda AWS IoT Greengrass .
1. **Per eseguire senza containerizzazione:**
+ Per **Utente e gruppo di sistema, scegli**. **Another user ID/group ID** Per **ID utente di sistema**, immettere**0**. Per **ID del gruppo di sistema**, immettere**0**.
Ciò consente alla funzione Lambda di funzionare come root. Per ulteriori informazioni sull'esecuzione come root, consulta[Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
**Suggerimento**
È inoltre necessario aggiornare il `config.json` file per concedere l'accesso root alla funzione Lambda. Per la procedura, vedi[Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
+ **Per la **containerizzazione della funzione Lambda**, scegli Nessun contenitore.**
Per ulteriori informazioni sull'esecuzione senza containerizzazione, consulta. [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations)
+ Per **Timeout**, immettere **10 seconds**.
+ **Per **Pinned**, scegli True.**
Per ulteriori informazioni, consulta [Configurazione del ciclo di vita per le funzioni Greengrass Lambda](lambda-functions.md#lambda-lifecycle).
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Per **Utente e gruppo di sistema**, scegli **Usa i valori predefiniti del gruppo**.
+ **Per la **containerizzazione delle funzioni Lambda**, scegli Usa default di gruppo.**
+ Per **Memory limit (Limite memoria)**, immettere **96 MB**.
+ Per **Timeout**, immettere **10 seconds**.
+ **Per **Pinned**, scegli True.**
Per ulteriori informazioni, consulta [Configurazione del ciclo di vita per le funzioni Greengrass Lambda](lambda-functions.md#lambda-lifecycle).
1. In **Environment variables (Variabili di ambiente)**, creare una coppia chiave-valore. Una coppia chiave-valore è richiesta dalle funzioni che interagiscono con i MXNet modelli su un Raspberry Pi.
Per la chiave, utilizzare MXNET\$1ENGINE\$1TYPE. Per il valore, usa. NaiveEngine
**Nota**
Nelle funzioni Lambda definite dall'utente, puoi facoltativamente impostare la variabile di ambiente nel codice della funzione.
1. Mantieni i valori predefiniti per tutte le altre proprietà e scegli **Aggiungi funzione Lambda**.
## Fase 6: aggiunta di risorse al gruppo Greengrass
In questo passaggio, crea risorse per il modulo telecamera e il modello di inferenza ML e associa le risorse alla funzione Lambda. Ciò consente alla funzione Lambda di accedere alle risorse sul dispositivo principale.
**Nota**
Se si esegue in modalità non containerizzata, è AWS IoT Greengrass possibile accedere alla GPU e alla fotocamera del dispositivo senza configurare queste risorse del dispositivo.
Innanzitutto, crea due risorse locali per la telecamera: una per la memoria condivisa e una per l'interfaccia del dispositivo. Per ulteriori informazioni sull'accesso alle risorse locali, consulta [Accedi alle risorse locali con funzioni e connettori Lambda](access-local-resources.md).
1. **Nella pagina di configurazione del gruppo, scegli la scheda Risorse.**
1. Nella sezione **Risorse locali**, scegli **Aggiungi risorsa locale**.
1. Nella pagina **Aggiungi una risorsa locale**, utilizza i seguenti valori:
+ Per **Resource Name (Nome risorsa)** immetti **videoCoreSharedMemory**.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per **Percorso del dispositivo locale**, immettere**/dev/vcsm**.
Il percorso del dispositivo è il percorso assoluto locale della risorsa del dispositivo. Questo percorso può fare riferimento solo a un dispositivo a caratteri o un dispositivo a blocchi in `/dev`.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
L'opzione **System group owner and file access permissions (proprietario del gruppo di sistema e autorizzazioni** di accesso ai file) consente di concedere ulteriori autorizzazioni di accesso ai file al processo Lambda. Per ulteriori informazioni, consulta [Autorizzazione di accesso ai file dell'owner del gruppo](access-local-resources.md#lra-group-owner).
1. A questo punto, aggiungi una risorsa del dispositivo locale per l'interfaccia della telecamera.
1. Scegli **Aggiungi risorsa locale**.
1. Nella pagina **Aggiungi una risorsa locale**, utilizza i seguenti valori:
+ Per **Resource Name (Nome risorsa)** immetti **videoCoreInterface**.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per **Percorso del dispositivo locale**, immettere**/dev/vchiq**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
1. Nella parte inferiore della pagina, scegli **Aggiungi** risorsa.
Ora aggiungi il modello di inferenza come una risorsa Machine Learning. Questo passaggio include il caricamento del pacchetto `squeezenet.zip` modello su Amazon S3.
1. Nella scheda **Risorse** per il tuo gruppo, nella sezione **Machine Learning**, scegli **Aggiungi risorsa di machine learning**.
1. Nella pagina **Aggiungi una risorsa di machine learning**, per **Nome risorsa**, inserisci**squeezenet\$1model**.
1. Per **Model source**, scegli **Usa un modello archiviato in S3, ad esempio un modello ottimizzato tramite Deep Learning Compiler**.
1. Per **S3 URI**, inserisci un percorso in cui viene salvato il bucket S3.
1. Seleziona **Sfoglia S3**. Si apre una nuova scheda nella console Amazon S3.
1. Nella scheda della console Amazon S3, carica il `squeezenet.zip` file in un bucket S3. Per informazioni, vedi [Come faccio a caricare file e cartelle in un bucket S3](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html)? nella *Guida per l'utente di Amazon Simple Storage Service*.
**Nota**
Affinché il bucket S3 sia accessibile, il nome del bucket deve contenere la stringa **greengrass** e il bucket deve trovarsi nella stessa regione per cui lo utilizzi. AWS IoT Greengrass Scegliere un nome univoco (ad esempio **greengrass-bucket-*user-id*-*epoch-time***). Non utilizzare un punto (`.`) nel nome del bucket.
1. Nella scheda della AWS IoT Greengrass console, individua e scegli il tuo bucket S3. Individuare e il file `squeezenet.zip` caricato e scegliere **Select (Seleziona)**. Potrebbe essere necessario scegliere **Refresh (Aggiorna)** per aggiornare l'elenco dei bucket e dei file disponibili.
1. Per **Destination path (Percorso di destinazione)**, immetti **/greengrass-machine-learning/mxnet/squeezenet**.
Questa è la destinazione del modello locale nello spazio dei nomi di runtime Lambda. Quando distribuisci il gruppo, AWS IoT Greengrass recupera il pacchetto del modello sorgente e quindi estrae il contenuto nella directory specificata. La funzione Lambda di esempio per questo tutorial è già configurata per utilizzare questo percorso (nella `model_path` variabile).
1. In **Proprietario del gruppo di sistema e autorizzazioni di accesso ai file**, scegli **Nessun gruppo di sistema**.
1. Scegliere **Add resource (Aggiungi risorsa)**.
### Utilizzo di modelli addestrati all' SageMaker intelligenza artificiale
Questo tutorial utilizza un modello archiviato in Amazon S3, ma puoi utilizzare facilmente anche modelli SageMaker AI. La AWS IoT Greengrass console ha un'integrazione SageMaker AI integrata, quindi non è necessario caricare manualmente questi modelli su Amazon S3. Per i requisiti e le limitazioni per l'utilizzo dei modelli di SageMaker intelligenza artificiale, consulta[Origini di modello supportate](ml-inference.md#supported-model-sources).
Per utilizzare un modello di SageMaker intelligenza artificiale:
+ Per **Model source**, scegli **Usa un modello addestrato all' AWS SageMaker intelligenza artificiale**, quindi scegli il nome del processo di formazione del modello.
+ Per **Percorso di destinazione**, inserisci il percorso della directory in cui la funzione Lambda cerca il modello.
## Fase 7: aggiunta di una sottoscrizione al gruppo Greengrass
In questa fase, aggiungere una sottoscrizione al gruppo. Questo abbonamento consente alla funzione Lambda di inviare risultati di previsione AWS IoT pubblicandoli su un argomento MQTT.
1. **Nella pagina di configurazione del gruppo, scegli la scheda **Abbonamenti**, quindi scegli Aggiungi abbonamento.**
1. Nella pagina dei **dettagli dell'abbonamento**, configura l'origine e la destinazione come segue:
1. In **Tipo di sorgente**, scegli **Funzione Lambda**, quindi scegli. **greengrassObjectClassification**
1. Nel **tipo di Target**, scegli **Servizio**, quindi scegli **IoT Cloud**.
1. Nel **filtro per argomenti****hello/world**, inserisci, quindi scegli **Crea abbonamento**.
## Fase 8: distribuzione del gruppo Greengrass
In questa fase, distribuire la versione corrente della definizione del gruppo nel dispositivo core Greengrass. La definizione contiene la funzione Lambda, le risorse e le configurazioni di sottoscrizione che hai aggiunto.
1. Assicurati che il AWS IoT Greengrass core sia in esecuzione. Esegui i seguenti comandi nel terminale di Raspberry Pi in base alle esigenze.
1. Per controllare se il daemon è in esecuzione:
```
ps aux | grep -E 'greengrass.*daemon'
```
Se l'output contiene una voce `root` per `/greengrass/ggc/packages/1.11.6/bin/daemon`, allora il daemon è in esecuzione.
**Nota**
La versione indicata nel percorso dipende dalla versione del software AWS IoT Greengrass Core installata sul dispositivo principale.
1. Per avviare il demone:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. **Nella pagina di configurazione del gruppo, scegli Deploy.**
![\[La pagina del gruppo con le opzioni Deployments (Distribuzioni) e Deploy (Distribuisci) evidenziate.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/console-group-deployments-deploy.png)
1. **Nella scheda **Funzioni Lambda, nella sezione Funzioni** **System Lambda**, seleziona **Rilevatore IP** e scegli Modifica.**
1. Nella finestra di dialogo **Modifica impostazioni del rilevatore IP**, seleziona Rileva **e sostituisci automaticamente gli endpoint del broker MQTT**.
1. Scegli **Save** (Salva).
Questo consente ai dispositivi di acquisire automaticamente informazioni di base sulla connettività, come, ad esempio indirizzo IP, DNS e numero della porta. Il rilevamento automatico è consigliato, ma supporta AWS IoT Greengrass anche gli endpoint specificati manualmente. Ti viene chiesto il metodo di individuazione solo la prima volta che il gruppo viene distribuito.
**Nota**
Se richiesto, concedi l'autorizzazione a creare il ruolo di [servizio Greengrass](service-role.md) e associarlo al Account AWS tuo ruolo attuale. Regione AWS Questo ruolo consente di accedere AWS IoT Greengrass alle tue risorse nei AWS servizi.
Nella pagina **Deployments (Distribuzioni)** vengono visualizzati il timestamp della distribuzione, l'ID versione e lo stato. Una volta completata, lo stato visualizzato per la distribuzione dovrebbe essere **Completato**.
Per ulteriori informazioni sulle implementazioni, consulta [Distribuisci AWS IoT Greengrass i gruppi su un core AWS IoT Greengrass](deployments.md). Per la risoluzione dei problemi, consultare [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md).
## Fase 9: esecuzione del test dell'app di inferenza
Ora puoi verificare se la distribuzione è configurata correttamente. Per eseguire il test, è necessario abbonarsi all'`hello/world`argomento e visualizzare i risultati della previsione pubblicati dalla funzione Lambda.
**Nota**
Se a dispositivo Raspberry Pi è collegato un monitor, il segnale attivo della telecamera viene visualizzato in una finestra di anteprima.
1. Nella AWS IoT console, in **Test**, scegli **MQTT** test client.
1. In **Subscriptions (Sottoscrizioni)**, utilizza i seguenti valori:
+ Per l’argomento della sottoscrizione, utilizzare ciao/mondo.
+ In **Configurazione aggiuntiva**, per la visualizzazione del **payload MQTT, scegli **Visualizza i payload**** come stringhe.
1. Scegli **Abbonati**.
Se il test ha esito positivo, i messaggi della funzione Lambda vengono visualizzati nella parte inferiore della pagina. Ogni messaggio contiene i primi cinque risultati predittivi dell'immagine nel formato: probabilità, ID classe prevista e nome della classe corrispondente.
![\[La pagina Subscriptions (Sottoscrizioni) in cui sono visualizzati i risultati del test con i dati del messaggio.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-inference/prediction-results.png)
### Risoluzione dei problemi di AWS IoT Greengrass inferenza ML
Se il test non viene completato correttamente, puoi provare a eseguire la procedura di risoluzione dei problemi riportata di seguito. Esegui i comandi nel terminale Raspberry Pi.
#### Controlla i log degli errori
1. Passare all'utente root e navigare alla directory `log`. L'accesso ai AWS IoT Greengrass log richiede i permessi di root.
```
sudo su
cd /greengrass/ggc/var/log
```
1. Nella directory `system`, controllare `runtime.log` o `python_runtime.log`.
Nella directory `user/region/account-id`, controllare `greengrassObjectClassification.log`.
Per ulteriori informazioni, consulta [Risoluzione dei problemi con i log](gg-troubleshooting.md#troubleshooting-logs).
##### Errore di decompressione in runtime.log
Se `runtime.log` contiene un errore simile al seguente, assicurati che il pacchetto del modello di origine `tar.gz` contenga una directory principale.
```
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
```
Se il pacchetto non dispone di una directory principale contenente i file del modello, ricomprimi il modello utilizzando il seguente comando:
```
tar -zcvf model.tar.gz ./model
```
Esempio:
```
─$ tar -zcvf test.tar.gz ./test
./test
./test/some.file
./test/some.file2
./test/some.file3
```
**Nota**
Non includere i caratteri finali `/*` in questo comando.
#### Verifica che la funzione Lambda sia implementata correttamente
1. Elenca il contenuto della Lambda distribuita nella `/lambda` directory. Prima di eseguire il comando, sostituisci i valori dei segnaposti.
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. Verifica che la directory contenga gli stessi file inclusi nel pacchetto di distribuzione `greengrassObjectClassification.zip` caricato in [Fase 4: Creare e pubblicare una funzione Lambda](#ml-console-create-lambda).
Assicurati inoltre che i file `.py` e le dipendenze si trovino nella root della directory.
#### Verifica che il modello di inferenza sia stato distribuito correttamente
1. Trova il numero di identificazione del processo (PID) del processo di runtime Lambda:
```
ps aux | grep 'lambda-function-name*'
```
Nell'output, il PID appare nella seconda colonna della riga per il processo di runtime Lambda.
1. Inserisci lo spazio dei nomi di runtime Lambda. Assicurati di sostituire il *pid* valore segnaposto prima di eseguire il comando.
**Nota**
Questa directory e il suo contenuto si trovano nello spazio dei nomi di runtime Lambda, quindi non sono visibili in un normale spazio dei nomi Linux.
```
sudo nsenter -t pid -m /bin/bash
```
1. Elenca i contenuti della directory locale specificata per la risorsa ML.
```
cd /greengrass-machine-learning/mxnet/squeezenet/
ls -ls
```
Dovrebbero essere visualizzati i seguenti file:
```
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
```
## Fasi successive
Successivamente, esplora altre app di inferenza. AWS IoT Greengrass fornisce altre funzioni Lambda che è possibile utilizzare per provare l'inferenza locale. Il pacchetto degli esempi è disponibile nella cartella delle librerie precompilate scaricata nella [Fase 2: Installare il framework MXNet](#install-mxnet).
## Configurazione di un dispositivo Intel Atom
Per eseguire questo tutorial su un dispositivo Intel Atom, è necessario fornire immagini di origine, configurare la funzione Lambda e aggiungere un'altra risorsa del dispositivo locale. Per utilizzare la GPU per l'inferenza, assicurarsi che sul dispositivo sia installato il seguente software:
+ OpenCL versione 1.0 o successiva
+ Python 3.7 e pip
**Nota**
Se il dispositivo è preconfigurato con Python 3.6, puoi invece creare un collegamento simbolico a Python 3.7. Per ulteriori informazioni, consulta [Step 2](#python-symlink).
+ [NumPy](https://pypi.org/project/numpy/)
+ [OpenCV su Wheels](https://pypi.org/project/opencv-python/)
1. Scarica immagini PNG o JPG statiche per la funzione Lambda da utilizzare per la classificazione delle immagini. L'esempio funziona in modo ottimale con file immagine di dimensioni ridotte.
Salva i file immagine nella directory contenente il file `greengrassObjectClassification.py` (o in una sottodirectory di questa directory). Si trova nel pacchetto di distribuzione della funzione Lambda in cui carichi. [Fase 4: Creare e pubblicare una funzione Lambda](#ml-console-create-lambda)
**Nota**
Se la utilizzi AWS DeepLens, puoi utilizzare la videocamera di bordo o montare la tua fotocamera per eseguire inferenze sulle immagini acquisite anziché sulle immagini statiche. Tuttavia, ti consigliamo di iniziare con le immagini statiche.
Se si utilizza una telecamera, assicurarsi che il pacchetto APT `awscam` sia installato e aggiornato. Per ulteriori informazioni, consulta [Aggiorna il tuo AWS DeepLens dispositivo nella Guida](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html) per gli *AWS DeepLens sviluppatori*.
1. Se non stai usando Python 3.7, assicurati di creare un collegamento simbolico da Python 3.x a Python 3.7. Questo configura il tuo dispositivo per usare Python 3 con. AWS IoT Greengrass Eseguire il seguente comando per individuare l'installazione di Python:
```
which python3
```
Eseguire il comando seguente per creare il collegamento simbolico.
```
sudo ln -s path-to-python-3.x/python3.x path-to-python-3.7/python3.7
```
Riavviare il dispositivo.
1. Modifica la configurazione della funzione Lambda. Segui la procedura riportata in [Fase 5: Aggiungere la funzione Lambda al gruppo Greengrass](#ml-console-config-lambda).
**Nota**
Ti consigliamo di eseguire la funzione Lambda senza containerizzazione a meno che il tuo business case non lo richieda. Ciò consente l'accesso alla GPU e alla fotocamera del dispositivo senza configurare le risorse del dispositivo. Se esegui senza containerizzazione, devi anche concedere l'accesso root alle tue funzioni Lambda AWS IoT Greengrass .
1. **Per eseguire senza containerizzazione:**
+ Per **Utente e gruppo di sistema, scegli**. **Another user ID/group ID** Per **ID utente di sistema**, immettere**0**. Per **ID del gruppo di sistema**, immettere**0**.
Ciò consente alla funzione Lambda di funzionare come root. Per ulteriori informazioni sull'esecuzione come root, consulta[Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
**Suggerimento**
È inoltre necessario aggiornare il `config.json` file per concedere l'accesso root alla funzione Lambda. Per la procedura, vedi[Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
+ **Per la **containerizzazione della funzione Lambda**, scegli Nessun contenitore.**
Per ulteriori informazioni sull'esecuzione senza containerizzazione, consulta. [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations)
+ Aggiornare il valore **Timeout** a 5 secondi. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **In **Bloccato, scegli** True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
+ Per **Lambda lifecycle (Ciclo di vita Lambda)**, scegli **Make this function long-lived and keep it running indefinitely (Rendi questa funzione di lunga durata e mantieni in esecuzione a tempo indeterminato)**.
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Aggiornare il valore **Timeout** a 5 secondi. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **Per **Pinned**, scegli True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. **Se è in esecuzione in modalità containerizzata**, aggiungi la risorsa del dispositivo locale richiesta per concedere l'accesso alla GPU del dispositivo.
**Nota**
Se esegui in modalità non containerizzata, AWS IoT Greengrass puoi accedere alla GPU del dispositivo senza configurare le risorse del dispositivo.
1. **Nella pagina di configurazione del gruppo, scegli la scheda Risorse.**
1. Scegli **Aggiungi risorsa locale**.
1. Definisci la risorsa:
+ Per **Resource Name (Nome risorsa)** immetti **renderD128**.
+ Per **Tipo di risorsa**, scegli **Dispositivo locale**.
+ Per **Device path (Percorso dispositivo)**, immetti **/dev/dri/renderD128**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
+ Per le **affiliazioni alle funzioni Lambda**, concedi l'**accesso in lettura e scrittura alla** tua funzione Lambda.
## Configurazione di un NVIDIA Jetson TX2
Per eseguire questo tutorial su un NVIDIA Jetson TX2, fornisci immagini sorgente e configura la funzione Lambda. Se stai utilizzando la GPU, devi anche aggiungere le risorse locali del dispositivo.
1. Assicurati che il tuo dispositivo Jetson sia configurato in modo da poter installare il software Core. AWS IoT Greengrass Per ulteriori informazioni sulla configurazione del dispositivo, consulta [Configurazione di altri dispositivi](setup-filter.other.md).
1. Apri la MXNet documentazione, vai a [Installazione MXNet su un Jetson](https://mxnet.apache.org/get_started/jetson_setup) e segui le istruzioni per l'installazione MXNet sul dispositivo Jetson.
**Nota**
Se vuoi creare MXNet dal codice sorgente, segui le istruzioni per creare la libreria condivisa. Modifica le seguenti impostazioni nel tuo `config.mk` file per lavorare con un dispositivo Jetson TX2 :
Aggiungere `-gencode arch=compute-62, code=sm_62` all'impostazione `CUDA_ARCH`.
Attivare CUDA.
```
USE_CUDA = 1
```
1. Scarica immagini PNG o JPG statiche per la funzione Lambda da utilizzare per la classificazione delle immagini. L'app funziona in modo ottimale con i file immagine di dimensioni ridotte. In alternativa, puoi implementare una telecamera sulla scheda Jetson per acquisire le immagini di origine.
Salvare i file immagine nella directory contenente il file `greengrassObjectClassification.py`. È possibile salvarli anche in una sottodirectory di questa directory. Questa directory si trova nel pacchetto di distribuzione della funzione Lambda in cui carichi. [Fase 4: Creare e pubblicare una funzione Lambda](#ml-console-create-lambda)
1. Crea un collegamento simbolico da Python 3.7 a Python 3.6 con cui usare Python 3. AWS IoT Greengrass Eseguire il seguente comando per individuare l'installazione di Python:
```
which python3
```
Eseguire il comando seguente per creare il collegamento simbolico.
```
sudo ln -s path-to-python-3.6/python3.6 path-to-python-3.7/python3.7
```
Riavviare il dispositivo.
1. Assicurati che l'account di `ggc_user` sistema possa utilizzare il framework: MXNet
```
“sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
1. Modifica la configurazione della funzione Lambda. Segui la procedura riportata in [Fase 5: Aggiungere la funzione Lambda al gruppo Greengrass](#ml-console-config-lambda).
**Nota**
Ti consigliamo di eseguire la funzione Lambda senza containerizzazione a meno che il tuo business case non lo richieda. Ciò consente l'accesso alla GPU e alla fotocamera del dispositivo senza configurare le risorse del dispositivo. Se esegui senza containerizzazione, devi anche concedere l'accesso root alle tue funzioni Lambda AWS IoT Greengrass .
1. **Per eseguire senza containerizzazione:**
+ Per **Utente e gruppo di sistema, scegli**. **Another user ID/group ID** Per **ID utente di sistema**, immettere**0**. Per **ID del gruppo di sistema**, immettere**0**.
Ciò consente alla funzione Lambda di funzionare come root. Per ulteriori informazioni sull'esecuzione come root, consulta[Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
**Suggerimento**
È inoltre necessario aggiornare il `config.json` file per concedere l'accesso root alla funzione Lambda. Per la procedura, vedi[Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
+ **Per la **containerizzazione della funzione Lambda**, scegli Nessun contenitore.**
Per ulteriori informazioni sull'esecuzione senza containerizzazione, consulta. [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations)
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
+ In **Variabili di ambiente**, aggiungi le seguenti coppie chiave-valore alla tua funzione Lambda. Questo configura l'utilizzo del framework AWS IoT Greengrass . MXNet
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-console.html)
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Aumenta il valore di **Memory limit (Limite memoria)**. Utilizzare 500 MB per la CPU o almeno 2000 MB per la GPU.
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
+ In **Variabili di ambiente**, aggiungi le seguenti coppie chiave-valore alla tua funzione Lambda. Questo configura l'utilizzo del framework AWS IoT Greengrass . MXNet
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-console.html)
1. **Se è in esecuzione in modalità containerizzata**, aggiungi le seguenti risorse del dispositivo locale per concedere l'accesso alla GPU del dispositivo. Segui la procedura riportata in [Fase 6: aggiunta di risorse al gruppo Greengrass](#ml-console-add-resources).
**Nota**
Se esegui in modalità non containerizzata, AWS IoT Greengrass puoi accedere alla GPU del dispositivo senza configurare le risorse del dispositivo.
Per ogni risorsa:
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file, scegli Aggiungi automaticamente le autorizzazioni** **del file system del gruppo di sistema proprietario della risorsa**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-console.html)
1. **Se è in esecuzione in modalità containerizzata**, aggiungi la seguente risorsa di volume locale per concedere l'accesso alla fotocamera del tuo dispositivo. Segui la procedura riportata in [Fase 6: aggiunta di risorse al gruppo Greengrass](#ml-console-add-resources).
**Nota**
Se si esegue in modalità non containerizzata, è AWS IoT Greengrass possibile accedere alla fotocamera del dispositivo senza configurare le risorse di volume.
+ Per **Resource type (Tipo di risorsa)**, scegli **Volume**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file**, scegli **Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-console.html)
# Come configurare l'inferenza ottimizzata dell'apprendimento automatico utilizzando Console di gestione AWS
Per seguire i passaggi di questo tutorial, devi utilizzare AWS IoT Greengrass Core v1.10 o versione successiva.
Puoi utilizzare il compilatore di deep learning SageMaker AI Neo per ottimizzare l'efficienza di previsione dei modelli di inferenza nativi di machine learning in Tensorflow, Apache MXNet PyTorch, ONNX e framework per un ingombro ridotto e prestazioni più veloci. XGBoost Puoi quindi scaricare il modello ottimizzato e installare il runtime di deep learning SageMaker AI Neo e distribuirlo sui tuoi dispositivi per un'inferenza più rapida. AWS IoT Greengrass
Questo tutorial descrive come utilizzare Console di gestione AWS per configurare un gruppo Greengrass per eseguire un esempio di inferenza Lambda che riconosce le immagini da una fotocamera localmente, senza inviare dati al cloud. L'esempio di inferenza seguente consente di accedere al modulo della telecamera in un Raspberry Pi. In questo tutorial, scarichi un modello preconfezionato addestrato da Resnet-50 e ottimizzato nel compilatore di deep learning Neo. Il modello viene quindi utilizzato per eseguire la classificazione locale delle immagini sul dispositivo. AWS IoT Greengrass
Il tutorial include le seguenti fasi di alto livello:
1. [Configurare il dispositivo Raspberry Pi](#config-raspberry-pi-dlc)
1. [Installazione di Neo Deep Learning Runtime](#install-dlr)
1. [Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda)
1. [Aggiungere la funzione Lambda al gruppo](#ml-console-dlc-config-lambda)
1. [Aggiunta della risorsa del modello ottimizzato Neo al gruppo](#ml-console-dlc-add-resources)
1. [Aggiunta della risorsa del dispositivo della telecamera al gruppo](#ml-console-dlc-add-cam-resource)
1. [Aggiunta di sottoscrizioni al gruppo](#ml-console-dlc-add-subscription)
1. [Distribuzione del gruppo.](#ml-console-dlc-deploy-group)
1. [Test dell'esempio](#ml-console-dlc-test-app)
## Prerequisiti
Per completare questo tutorial, è necessario quanto segue:
+ Raspberry Pi 4 Model B o Raspberry Pi 3 Model B/B\$1, configurati e configurati per l'uso con. AWS IoT Greengrass Per configurare Raspberry Pi con AWS IoT Greengrass, eseguire lo script di [configurazione del dispositivo Greengrass](quick-start.md) o assicurarsi di aver completato il [modulo 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) e il [modulo 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) di [Iniziare con AWS IoT Greengrass](gg-gs.md).
**Nota**
Il Raspberry Pi potrebbe richiedere un [alimentatore](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/) da 2,5 A per eseguire i framework di deep learning generalmente utilizzati per la classificazione delle immagini. Un alimentatore con una potenza nominale inferiore potrebbe causare il riavvio del dispositivo.
+ [Modulo della telecamera Raspberry Pi V2 da 8 Megapixel, 1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Per informazioni sulla configurazione della telecamera, consulta [Connessione della telecamera](https://www.raspberrypi.org/documentation/usage/camera/) nella documentazione di Raspberry Pi.
+ Un gruppo e un core Greengrass. Per informazioni su come creare un gruppo o un core Greengrass, consulta [Iniziare con AWS IoT Greengrass](gg-gs.md).
**Nota**
Questo tutorial utilizza un Raspberry Pi, ma AWS IoT Greengrass supporta altre piattaforme, come [Intel Atom](#atom-lambda-dlc-config) e [NVIDIA](#jetson-lambda-dlc-config) Jetson. TX2 Se si utilizza l'esempio Intel Atom, potrebbe essere necessario installare Python 3.6 invece di Python 3.7. Per informazioni sulla configurazione del dispositivo in modo da poter installare il software Core, consulta AWS IoT Greengrass . [Configurazione di altri dispositivi](setup-filter.other.md)
Per le piattaforme di terze parti che AWS IoT Greengrass non supportano, è necessario eseguire la funzione Lambda in modalità non containerizzata. Per l'esecuzione in modalità non containerizzata, è necessario eseguire la funzione Lambda come utente root. Per ulteriori informazioni, consultare [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations) e [Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
## Fase 1: Configurare il dispositivo Raspberry Pi
In questa fase, verranno installati gli aggiornamenti del sistema operativo Raspbian, il software del modulo della telecamera e le dipendenze Python e verrà abilitata l'interfaccia della telecamera.
Esegui i seguenti comandi nel terminale Raspberry Pi.
1. Installare gli aggiornamenti in Raspbian.
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. Installare l'interfaccia `picamera` per il modulo della telecamera e le altre librerie Python necessarie per questo tutorial.
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
Convalidare l'installazione:
+ Assicurati che l'installazione di Python 3.7 includa pip.
```
python3 -m pip
```
Se pip non è installato, scaricarlo dal [sito Web pip](https://pip.pypa.io/en/stable/installing/) ed eseguire il comando seguente.
```
python3 get-pip.py
```
+ Assicurati che la versione Python sia 3.7 o superiore.
```
python3 --version
```
Se l'output elenca una versione precedente, eseguire il comando seguente.
```
sudo apt-get install -y python3.7-dev
```
+ Assicurati che Setuptools e Picamera siano stati installati correttamente.
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Se l'output non contiene errori, la convalida ha esito positivo.
**Nota**
Se l'eseguibile Python installato sul dispositivo è `python3.7`, utilizzare `python3.7` invece di `python3` per i comandi in questo tutorial. Assicurati che l'installazione di pip sia mappata alla versione `python3.7` o `python3` corretta per evitare errori di dipendenza.
1. Riavvia il dispositivo Raspberry Pi.
```
sudo reboot
```
1. Apri lo strumento di configurazione di Raspberry Pi.
```
sudo raspi-config
```
1. Utilizza i tasti freccia per aprire **Interfacing Options (Opzioni di interfaccia)** e abilita l'interfaccia della telecamera. Se richiesto, consenti il riavvio del dispositivo.
1. Utilizza il seguente comando per eseguire il test della configurazione della telecamera.
```
raspistill -v -o test.jpg
```
Viene visualizzata una finestra di anteprima sul dispositivo Raspberry Pi, viene salvata un'immagine denominata `test.jpg` nella directory corrente e vengono visualizzati informazioni sulla telecamera nel terminale Raspberry Pi.
## Fase 2: installa il runtime di deep learning di Amazon SageMaker Neo
In questo passaggio, installa il Neo deep learning runtime (DLR) sul tuo Raspberry Pi.
**Nota**
Per questo tutorial si consiglia di installare la versione 1.1.0.
1. Accedere al Raspberry Pi da remoto.
```
ssh pi@your-device-ip-address
```
1. Aprire la documentazione DLR, aprire [Installazione DLR](https://neo-ai-dlr.readthedocs.io/en/latest/install.html) e individuare il wheel URL dei dispositivi Raspberry Pi. Seguire quindi le istruzioni per installare il DLR sul dispositivo. Ad esempio, è possibile utilizzare pip:
```
pip3 install rasp3b-wheel-url
```
1. Dopo aver installato il DLR, convalidare la seguente configurazione:
+ Assicurarsi che l'account di sistema `ggc_user` possa utilizzare la libreria DLR.
```
sudo -u ggc_user bash -c 'python3 -c "import dlr"'
```
+ Assicurati che NumPy sia installato.
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## Fase 3: Creare una funzione Lambda di inferenza
In questo passaggio, crea un pacchetto di distribuzione della funzione Lambda e una funzione Lambda. Quindi pubblicare una versione della funzione e creare un alias.
1. Sul computer, scaricare l'esempio DLR per Raspberry Pi da [Esempi di Machine Learning](what-is-gg.md#gg-ml-samples).
1. Decomprimere il file `dlr-py3-armv7l.tar.gz` scaricato.
```
cd path-to-downloaded-sample
tar -xvzf dlr-py3-armv7l.tar.gz
```
La directory `examples` nel pacchetto di esempio estratto contiene il codice di funzione e le dipendenze.
+ `inference.py` è il codice di inferenza utilizzato in questo tutorial. È possibile utilizzare questo codice come modello per creare la propria funzione di inferenza.
+ `greengrasssdk`è la versione 1.5.0 del AWS IoT Greengrass Core SDK for Python.
**Nota**
Se è disponibile una nuova versione, è possibile scaricarla e aggiornare la versione dell'SDK nel pacchetto di distribuzione. Per ulteriori informazioni, consulta [AWS IoT Greengrass Core SDK for GitHub Python on](https://github.com/aws/aws-greengrass-core-sdk-python/).
1. Comprimere il contenuto della directory `examples` in un file denominato `optimizedImageClassification.zip`. Questo è il pacchetto di distribuzione.
```
cd path-to-downloaded-sample/dlr-py3-armv7l/examples
zip -r optimizedImageClassification.zip .
```
Il pacchetto di distribuzione contiene il codice di funzione e le dipendenze. Ciò include il codice che richiama il runtime di Neo deep learning Python APIs per eseguire inferenze con i modelli del compilatore Neo deep learning.
**Nota**
Assicurarsi inoltre che i file `.py` e le dipendenze si trovino nella radice della directory.
1. Ora aggiungete la funzione Lambda al vostro gruppo Greengrass.
Dalla pagina della console Lambda, scegli **Funzioni** e scegli **Crea** funzione.
1. Scegli **Author da zero** e usa i seguenti valori per creare la tua funzione:
+ Nel campo **Function name (Nome funzione)**, immettere **optimizedImageClassification**.
+ In **Runtime**, scegliere **Python 3.7**.
Per **le autorizzazioni**, mantieni l'impostazione predefinita. Questo crea un ruolo di esecuzione che concede le autorizzazioni Lambda di base. Questo ruolo non viene utilizzato da. AWS IoT Greengrass
![\[La sezione sulle informazioni di base della pagina Crea funzione.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/gg-dlr-lambda-creation.png)
1. Scegli **Crea funzione**.
Ora carica il pacchetto di distribuzione della funzione Lambda e registra il gestore.
1. Nella scheda **Codice**, in **Codice sorgente**, scegli **Carica** da. Dal menu a discesa, scegli un **file.zip.**
![\[Il menu a discesa Carica da con il file.zip evidenziato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. **Scegli il pacchetto `optimizedImageClassification.zip` di distribuzione, quindi scegli Salva.**
1. Nella scheda **Codice** della funzione, in **Impostazioni di runtime**, scegli **Modifica**, quindi inserisci i seguenti valori.
+ In **Runtime**, scegliere **Python 3.7**.
+ Per **Gestore**, inserisci **inference.handler**.
Scegli **Save** (Salva).
![\[La sezione Impostazioni di runtime con Upload evidenziata.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-lambda-upload.png)
Successivamente, pubblica la prima versione della tua funzione Lambda. Quindi, creare un [alias per la versione](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html).
**Nota**
I gruppi Greengrass possono fare riferimento a una funzione Lambda tramite alias (consigliato) o per versione. L'utilizzo di un alias semplifica la gestione degli aggiornamenti del codice perché non è necessario modificare la tabella di sottoscrizione o la definizione del gruppo quando il codice della funzione viene aggiornato. È sufficiente invece indirizzare l'alias alla nuova versione della funzione.
1. Nel menu **Actions (Operazioni)**, seleziona **Publish new version (Pubblica nuova versione)**.
![\[L'opzione Publish new version (Pubblica nuova versione) nel menu Actions (Azioni).\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-publish-new.png)
1. Per **Version description (Descrizione versione)**, immettere **First version**, quindi scegliere **Publish (Pubblica)**.
1. Nella pagina di configurazione **optimizedImageClassification: 1**, dal menu **Azioni**, scegli **Crea alias**.
![\[L'opzione Create alias (Crea alias) nel menu Actions (Azioni).\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-create-alias.png)
1. Nella pagina **Create a new alias (Crea un nuovo alias)**, utilizza i seguenti valori:
+ In **Nome**, inserisci **mlTestOpt**.
+ Per **Version (Versione)**, immettere **1**.
**Nota**
AWS IoT Greengrass **non supporta gli alias Lambda per le versioni \$1LATEST.**
1. Scegli **Create** (Crea).
Ora aggiungete la funzione Lambda al vostro gruppo Greengrass.
## Fase 4: Aggiungere la funzione Lambda al gruppo Greengrass
In questo passaggio, aggiungi la funzione Lambda al gruppo, quindi configura il suo ciclo di vita.
Innanzitutto, aggiungi la funzione Lambda al tuo gruppo Greengrass.
1. Nel riquadro di navigazione della AWS IoT console, in **Gestione**, espandi **i dispositivi Greengrass**, quindi scegli **Gruppi (V1**).
1. **Nella pagina di configurazione dei gruppi, scegli la scheda **Funzioni Lambda** e scegli Aggiungi.**
1. Scegli la **funzione Lambda** e seleziona. **optimizedImageClassification**
1. Nella **versione della funzione Lambda**, scegli l'alias della versione che hai pubblicato.
Quindi, configura il ciclo di vita della funzione Lambda.
1. Nella sezione di **configurazione della funzione Lambda**, apporta i seguenti aggiornamenti.
**Nota**
Ti consigliamo di eseguire la funzione Lambda senza containerizzazione a meno che il tuo business case non lo richieda. Ciò consente l'accesso alla GPU e alla fotocamera del dispositivo senza configurare le risorse del dispositivo. Se esegui senza containerizzazione, devi anche concedere l'accesso root alle tue funzioni Lambda AWS IoT Greengrass .
1. **Per eseguire senza containerizzazione:**
+ Per **Utente e gruppo di sistema, scegli**. **Another user ID/group ID** Per **ID utente di sistema**, immettere**0**. Per **ID del gruppo di sistema**, immettere**0**.
Ciò consente alla funzione Lambda di funzionare come root. Per ulteriori informazioni sull'esecuzione come root, consulta[Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
**Suggerimento**
È inoltre necessario aggiornare il `config.json` file per concedere l'accesso root alla funzione Lambda. Per la procedura, vedi[Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
+ **Per la **containerizzazione della funzione Lambda**, scegli Nessun contenitore.**
Per ulteriori informazioni sull'esecuzione senza containerizzazione, consulta. [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations)
+ Per **Timeout**, immettere **10 seconds**.
+ **Per **Pinned**, scegli True.**
Per ulteriori informazioni, consulta [Configurazione del ciclo di vita per le funzioni Greengrass Lambda](lambda-functions.md#lambda-lifecycle).
+ **In **Parametro aggiuntivo**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Per **Utente e gruppo di sistema**, scegli **Usa i valori predefiniti del gruppo**.
+ **Per la **containerizzazione delle funzioni Lambda**, scegli Usa default di gruppo.**
+ Per **Memory limit (Limite memoria)**, immettere **1024 MB**.
+ Per **Timeout**, immettere **10 seconds**.
+ **Per **Pinned**, scegli True.**
Per ulteriori informazioni, consulta [Configurazione del ciclo di vita per le funzioni Greengrass Lambda](lambda-functions.md#lambda-lifecycle).
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. Scegli **Aggiungi funzione Lambda**.
## Passaggio 5: aggiungere una risorsa modello ottimizzata per SageMaker AI NEO al gruppo Greengrass
In questo passaggio, crea una risorsa per il modello di inferenza ML ottimizzato e caricala in un bucket Amazon S3. Quindi, individua il modello caricato da Amazon S3 nella AWS IoT Greengrass console e associa la risorsa appena creata alla funzione Lambda. In questo modo la funzione potrà accedere alle risorse nel dispositivo core.
1. Nel computer, passare alla directory `resnet50` nel pacchetto di esempio decompresso in [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda).
**Nota**
Se si utilizza l'esempio NVIDIA Jetson, è necessario utilizzare la directory `resnet18` nel pacchetto di esempio. Per ulteriori informazioni, consulta [Configurazione di un NVIDIA Jetson TX2](#jetson-lambda-dlc-config).
```
cd path-to-downloaded-sample/dlr-py3-armv7l/models/resnet50
```
Questa directory contiene artefatti di modelli precompilati di un modello di classificazione delle immagini basato su Resnet-50.
1. Comprimere i file all'interno della directory `resnet50` in un file denominato `resnet50.zip`.
```
zip -r resnet50.zip .
```
1. Nella pagina di configurazione del AWS IoT Greengrass gruppo, scegli la scheda **Risorse**. Accedi alla sezione **Machine Learning** e scegli **Add Machine Learning resource (Aggiungi risorsa Machine Learning)**. Nella pagina **Create a Machine Learning resource (Crea una risorsa Machine Learning)**, per **Resource name (Nome risorsa)**, immetti **resnet50\$1model**.
1. Per **Model source**, scegli **Usa un modello archiviato in S3, ad esempio un modello ottimizzato tramite Deep Learning Compiler**.
1. **In **URI S3**, scegli Browse S3.**
**Nota**
Attualmente, i modelli di SageMaker intelligenza artificiale ottimizzati vengono archiviati automaticamente in Amazon S3. Puoi trovare il modello ottimizzato nel tuo bucket Amazon S3 utilizzando questa opzione. Per ulteriori informazioni sull'ottimizzazione dei modelli nell' SageMaker intelligenza artificiale, consulta la documentazione di [SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
1. Scegli **Upload a model (Carica un modello)**.
1. Nella scheda della console Amazon S3, carica il file zip in un bucket Amazon S3. Per informazioni, vedi [Come faccio a caricare file e cartelle in un bucket S3](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html)? nella *Guida per l'utente di Amazon Simple Storage Service*.
**Nota**
Il nome del bucket deve contenere la stringa **greengrass**. Scegliere un nome univoco (ad esempio **greengrass-dlr-bucket-*user-id*-*epoch-time***). Non utilizzare un punto (`.`) nel nome del bucket.
1. Nella scheda AWS IoT Greengrass console, individua e scegli il tuo bucket Amazon S3. Individuare e il file `resnet50.zip` caricato e scegliere **Select (Seleziona)**. Potrebbe essere necessario aggiornare la pagina per aggiornare l'elenco dei bucket e dei file disponibili.
1. In **Percorso di destinazione, inserisci**. **/ml\$1model**
![\[Il percorso di destinazione aggiornato.\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/images/ml-dlc-inference/local-path.png)
Questa è la destinazione del modello locale nello spazio dei nomi di runtime Lambda. Quando distribuisci il gruppo, AWS IoT Greengrass recupera il pacchetto del modello sorgente e quindi estrae il contenuto nella directory specificata.
**Nota**
Ti consigliamo di utilizzare lo stesso percorso fornito per il percorso locale. Se in questa fase utilizzi un percorso di destinazione del modello locale diverso, alcuni comandi di risoluzione dei problemi specificati in questo tutorial potrebbero risultare imprecisi. Se utilizzi un percorso diverso, dovrai impostare una variabile di ambiente `MODEL_PATH` che utilizzi lo stesso percorso specificato qui. Per informazioni sulle variabili di ambiente, consulta [Variabili di ambiente AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html).
1. **Se è in esecuzione in modalità containerizzata:**
1. In **Proprietario del gruppo di sistema e autorizzazioni di accesso ai file, scegli **Specificare il gruppo di sistema** e le autorizzazioni**.
1. **Scegli **Accesso in sola lettura**, quindi scegli Aggiungi risorsa.**
## Fase 6: aggiunta della risorsa del dispositivo della telecamera al gruppo Greengrass
In questo passaggio, crea una risorsa per il modulo fotocamera e associala alla funzione Lambda. Ciò consente alla funzione Lambda di accedere alla risorsa sul dispositivo principale.
**Nota**
Se si esegue in modalità non containerizzata, è AWS IoT Greengrass possibile accedere alla GPU e alla fotocamera del dispositivo senza configurare questa risorsa del dispositivo.
1. **Nella pagina di configurazione del gruppo, scegli la scheda Risorse.**
1. Nella scheda **Risorse locali**, scegli **Aggiungi risorsa locale**.
1. Nella pagina **Aggiungi una risorsa locale**, utilizza i seguenti valori:
+ Per **Resource Name (Nome risorsa)** immetti **videoCoreSharedMemory**.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per **Percorso del dispositivo locale**, immettere**/dev/vcsm**.
Il percorso del dispositivo è il percorso assoluto locale della risorsa del dispositivo. Questo percorso fa riferimento solo a un dispositivo a caratteri o un dispositivo a blocchi in `/dev`.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
L'opzione **Group owner file access permission (Autorizzazione per l'accesso al file del proprietario del gruppo)** consente di concedere al processo Lambda ulteriori autorizzazioni di accesso ai file. Per ulteriori informazioni, consulta [Autorizzazione di accesso ai file dell'owner del gruppo](access-local-resources.md#lra-group-owner).
1. Nella parte inferiore della pagina, scegli **Aggiungi** risorsa.
1. Dalla scheda **Risorse**, crea un'altra risorsa locale scegliendo **Aggiungi** e utilizza i seguenti valori:
+ Per **Resource Name (Nome risorsa)** immetti **videoCoreInterface**.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per **Percorso del dispositivo locale**, immettere**/dev/vchiq**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
1. Scegliere **Add resource (Aggiungi risorsa)**.
## Fase 7: aggiunta di sottoscrizioni al gruppo Greengrass
In questa fase, si aggiungono le sottoscrizioni al gruppo. Questi abbonamenti consentono alla funzione Lambda di inviare risultati AWS IoT di previsione pubblicandoli su un argomento MQTT.
1. **Nella pagina di configurazione del gruppo, scegli la scheda **Abbonamenti**, quindi scegli Aggiungi abbonamento.**
1. Nella pagina **Crea un abbonamento**, configura l'origine e la destinazione come segue:
1. In **Tipo di sorgente**, scegli **Funzione Lambda**, quindi scegli. **optimizedImageClassification**
1. Nel **tipo di Target**, scegli **Servizio**, quindi scegli **IoT Cloud**.
1. Nel **filtro Argomento****/resnet-50/predictions**, inserisci, quindi scegli **Crea abbonamento**.
1. Aggiungere un secondo abbonamento. Scegli la scheda **Abbonamenti**, scegli **Aggiungi abbonamento** e configura l'origine e la destinazione come segue:
1. In **Tipo di origine**, scegli **Servizi**, quindi scegli **IoT Cloud**.
1. In **Tipo di destinazione**, scegli **Funzione Lambda**, quindi scegli. **optimizedImageClassification**
1. Nel **filtro Argomento**, inserisci**/resnet-50/test**, quindi scegli **Crea abbonamento**.
## Fase 8: distribuzione del gruppo Greengrass
In questa fase, distribuire la versione corrente della definizione del gruppo nel dispositivo core Greengrass. La definizione contiene la funzione Lambda, le risorse e le configurazioni di sottoscrizione che hai aggiunto.
1. Assicurati che il AWS IoT Greengrass core sia in esecuzione. Esegui i seguenti comandi nel terminale di Raspberry Pi in base alle esigenze.
1. Per controllare se il daemon è in esecuzione:
```
ps aux | grep -E 'greengrass.*daemon'
```
Se l'output contiene una voce `root` per `/greengrass/ggc/packages/latest-core-version/bin/daemon`, allora il daemon è in esecuzione.
1. Per avviare il demone:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. **Nella pagina di configurazione del gruppo, scegli Deploy.**
1. **Nella scheda **Funzioni Lambda**, seleziona **Rilevatore IP** e scegli Modifica.**
1. **Nella finestra di dialogo **Modifica impostazioni del rilevatore IP**, seleziona Rileva **automaticamente e sostituisci gli endpoint del broker MQTT e** scegli Salva.**
Questo consente ai dispositivi di acquisire automaticamente informazioni di base sulla connettività, come, ad esempio indirizzo IP, DNS e numero della porta. Il rilevamento automatico è consigliato, ma supporta AWS IoT Greengrass anche gli endpoint specificati manualmente. Ti viene chiesto il metodo di individuazione solo la prima volta che il gruppo viene distribuito.
**Nota**
Se richiesto, concedi l'autorizzazione a creare il ruolo di [servizio Greengrass](service-role.md) e associarlo al Account AWS tuo ruolo attuale. Regione AWS Questo ruolo consente di accedere AWS IoT Greengrass alle tue risorse nei AWS servizi.
Nella pagina **Deployments (Distribuzioni)** vengono visualizzati il timestamp della distribuzione, l'ID versione e lo stato. Una volta completata, lo stato visualizzato per la distribuzione dovrebbe essere **Completato**.
Per ulteriori informazioni sulle implementazioni, consulta [Distribuisci AWS IoT Greengrass i gruppi su un core AWS IoT Greengrass](deployments.md). Per la risoluzione dei problemi, consultare [Risoluzione dei problemi AWS IoT Greengrass](gg-troubleshooting.md).
## Esecuzione del test dell'esempio di inferenza
Ora puoi verificare se la distribuzione è configurata correttamente. Per eseguire il test, devi abbonarti all'argomento `/resnet-50/predictions` e pubblicare eventuali messaggi nell'argomento `/resnet-50/test`. Questo attiva la funzione Lambda per scattare una foto con il tuo Raspberry Pi ed eseguire inferenze sull'immagine che cattura.
**Nota**
Se si utilizza l'esempio di NVIDIA Jetson, assicurarsi di utilizzare invece gli argomenti `resnet-18/predictions` e `resnet-18/test`.
**Nota**
Se a dispositivo Raspberry Pi è collegato un monitor, il segnale attivo della telecamera viene visualizzato in una finestra di anteprima.
1. **Nella home page della AWS IoT console, in Test, scegli MQTT **test client**.**
1. Per **gli abbonamenti**, scegliete **Iscriviti a un argomento**. Utilizzare i seguenti valori. Non modificare i valori predefiniti delle altre opzioni:
+ Per **Argomento sottoscrizione**, immetti **/resnet-50/predictions**.
+ In **Configurazione aggiuntiva**, per la visualizzazione del **payload MQTT, scegli **Visualizza i payload**** come stringhe.
1. Scegli **Abbonati**.
1. **Scegliete **Pubblica su un argomento**, immettetelo **/resnet-50/test** come **nome dell'argomento** e scegliete Pubblica.**
1. Se il test viene completato senza errori, il messaggio pubblicato richiederà a Raspberry Pi di acquisire un'immagine. Nella parte inferiore della pagina viene visualizzato un messaggio della funzione Lambda. Questo messaggio contiene il risultato predittivo dell'immagine nel formato: nome classe prevista, probabilità e picco di utilizzo della memoria.
## Configurazione di un dispositivo Intel Atom
Per eseguire questo tutorial su un dispositivo Intel Atom, è necessario fornire immagini di origine, configurare la funzione Lambda e aggiungere un'altra risorsa del dispositivo locale. Per utilizzare la GPU per l'inferenza, assicurarsi che sul dispositivo sia installato il seguente software:
+ OpenCL versione 1.0 o successiva
+ Python 3.7 e pip
+ [NumPy](https://pypi.org/project/numpy/)
+ [OpenCV su Wheels](https://pypi.org/project/opencv-python/)
1. Scarica immagini PNG o JPG statiche per la funzione Lambda da utilizzare per la classificazione delle immagini. L'esempio funziona in modo ottimale con file immagine di dimensioni ridotte.
Salva i file immagine nella directory contenente il file `inference.py` (o in una sottodirectory di questa directory). Si trova nel pacchetto di distribuzione della funzione Lambda in cui carichi. [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda)
**Nota**
Se la utilizzi AWS DeepLens, puoi utilizzare la videocamera di bordo o montare la tua fotocamera per eseguire inferenze sulle immagini acquisite anziché sulle immagini statiche. Tuttavia, ti consigliamo di iniziare con le immagini statiche.
Se si utilizza una telecamera, assicurarsi che il pacchetto APT `awscam` sia installato e aggiornato. Per ulteriori informazioni, consulta [Aggiorna il tuo AWS DeepLens dispositivo nella Guida](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html) per gli *AWS DeepLens sviluppatori*.
1. Modifica la configurazione della funzione Lambda. Segui la procedura riportata in [Fase 4: Aggiungere la funzione Lambda al gruppo Greengrass](#ml-console-dlc-config-lambda).
**Nota**
Ti consigliamo di eseguire la funzione Lambda senza containerizzazione a meno che il tuo business case non lo richieda. Ciò consente l'accesso alla GPU e alla fotocamera del dispositivo senza configurare le risorse del dispositivo. Se esegui senza containerizzazione, devi anche concedere l'accesso root alle tue funzioni Lambda AWS IoT Greengrass .
1. **Per eseguire senza containerizzazione:**
+ Per **Utente e gruppo di sistema, scegli**. **Another user ID/group ID** Per **ID utente di sistema**, immettere**0**. Per **ID del gruppo di sistema**, immettere**0**.
Ciò consente alla funzione Lambda di funzionare come root. Per ulteriori informazioni sull'esecuzione come root, consulta[Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
**Suggerimento**
È inoltre necessario aggiornare il `config.json` file per concedere l'accesso root alla funzione Lambda. Per la procedura, vedi[Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
+ **Per la **containerizzazione della funzione Lambda**, scegli Nessun contenitore.**
Per ulteriori informazioni sull'esecuzione senza containerizzazione, consulta. [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations)
+ Aumenta il valore di **Timeout** a 2 minuti. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **Per **Pinned**, scegli True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Aumenta il valore di **Memory limit (Limite memoria)** a 3000 MB.
+ Aumenta il valore di **Timeout** a 2 minuti. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **Per **Pinned**, scegli True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. Aggiungere la risorsa del modello ottimizzato Neo al gruppo Caricare le risorse del modello nella directory `resnet50` del pacchetto di esempio decompresso in [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda). Questa directory contiene artefatti di modelli precompilati di un modello di classificazione delle immagini basato su Resnet-50. Segui la procedura descritta in [Passaggio 5: aggiungere una risorsa modello ottimizzata per SageMaker AI NEO al gruppo Greengrass](#ml-console-dlc-add-resources), con i seguenti aggiornamenti:
+ Comprimere i file all'interno della directory `resnet50` in un file denominato `resnet50.zip`.
+ Nella pagina **Create a Machine Learning resource (Crea una risorsa Machine Learning)**, per **Resource name (Nome risorsa)**, immetti **resnet50\$1model**.
+ Caricare il file `resnet50.zip`
1. **Se è in esecuzione in modalità containerizzata**, aggiungi la risorsa del dispositivo locale richiesta per concedere l'accesso alla GPU del dispositivo.
**Nota**
Se esegui in modalità non containerizzata, AWS IoT Greengrass puoi accedere alla GPU del dispositivo senza configurare le risorse del dispositivo.
1. **Nella pagina di configurazione del gruppo, scegli la scheda Risorse.**
1. Nella sezione **Risorse locali**, scegli **Aggiungi risorsa locale**.
1. Definisci la risorsa:
+ Per **Resource Name (Nome risorsa)** immetti **renderD128**.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per **Percorso del dispositivo locale**, immettere**/dev/dri/renderD128**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
## Configurazione di un NVIDIA Jetson TX2
Per eseguire questo tutorial su un NVIDIA Jetson TX2, fornisci immagini sorgente, configura la funzione Lambda e aggiungi altre risorse locali del dispositivo.
1. Assicurati che il tuo dispositivo Jetson sia configurato in modo da poter installare il software AWS IoT Greengrass Core e utilizzare la GPU per l'inferenza. Per ulteriori informazioni sulla configurazione del dispositivo, consulta [Configurazione di altri dispositivi](setup-filter.other.md). Per utilizzare la GPU per l'inferenza su un NVIDIA Jetson TX2, devi installare CUDA 10.0 e cuDNN 7.0 sul tuo dispositivo quando immagini la tua scheda con Jetpack 4.3.
1. Scarica immagini PNG o JPG statiche per la funzione Lambda da utilizzare per la classificazione delle immagini. L'esempio funziona in modo ottimale con file immagine di dimensioni ridotte.
Salvare i file immagine nella directory contenente il file `inference.py`. È possibile salvarli anche in una sottodirectory di questa directory. Questa directory si trova nel pacchetto di distribuzione della funzione Lambda in cui carichi. [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda)
**Nota**
In alternativa, puoi scegliere di implementare una telecamera sulla scheda Jetson per acquisire le immagini di origine. Tuttavia, ti consigliamo di iniziare con le immagini statiche.
1. Modifica la configurazione della funzione Lambda. Segui la procedura riportata in [Fase 4: Aggiungere la funzione Lambda al gruppo Greengrass](#ml-console-dlc-config-lambda).
**Nota**
Ti consigliamo di eseguire la funzione Lambda senza containerizzazione a meno che il tuo business case non lo richieda. Ciò consente l'accesso alla GPU e alla fotocamera del dispositivo senza configurare le risorse del dispositivo. Se esegui senza containerizzazione, devi anche concedere l'accesso root alle tue funzioni Lambda AWS IoT Greengrass .
1. **Per eseguire senza containerizzazione:**
+ Per **Esegui come, scegli**. **Another user ID/group ID** Per **UID**, inserisci**0**. Per **GUID, immettere**. **0**
Ciò consente alla funzione Lambda di funzionare come root. Per ulteriori informazioni sull'esecuzione come root, consulta[Impostazione dell'identità di accesso predefinita per le funzioni Lambda in un gruppo](lambda-group-config.md#lambda-access-identity-groupsettings).
**Suggerimento**
È inoltre necessario aggiornare il `config.json` file per concedere l'accesso root alla funzione Lambda. Per la procedura, vedi[Esecuzione di una funzione Lambda come utente root](lambda-group-config.md#lambda-running-as-root).
+ **Per la **containerizzazione della funzione Lambda**, scegli Nessun contenitore.**
Per ulteriori informazioni sull'esecuzione senza containerizzazione, consulta. [Considerazioni sulla scelta della containerizzazione delle funzioni Lambda](lambda-group-config.md#lambda-containerization-considerations)
+ Aumenta il valore **Timeout** a 5 minuti. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **Per **Pinned**, scegli True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. **Per eseguire invece in modalità containerizzata:**
**Nota**
Si sconsiglia l'esecuzione in modalità containerizzata a meno che il business case non lo richieda.
+ Aumenta il valore di **Memory limit (Limite memoria)**. Per utilizzare il modello fornito in modalità GPU, utilizza almeno 2000 MB.
+ Aumenta il valore **Timeout** a 5 minuti. In questo modo, il timeout della richiesta non viene eseguito troppo presto. L'esecuzione dell'inferenza richiede alcuni minuti dopo la configurazione.
+ **Per **Pinned**, scegli True.**
+ **In **Parametri aggiuntivi**, per **Accesso in lettura alla directory /sys**, scegli Abilitato.**
1. Aggiungere la risorsa del modello ottimizzato Neo al gruppo Caricare le risorse del modello nella directory `resnet18` del pacchetto di esempio decompresso in [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda). Questa directory contiene artefatti di modelli precompilati di un modello di classificazione delle immagini basato su Resnet-18. Segui la procedura descritta in [Passaggio 5: aggiungere una risorsa modello ottimizzata per SageMaker AI NEO al gruppo Greengrass](#ml-console-dlc-add-resources), con i seguenti aggiornamenti:
+ Comprimere i file all'interno della directory `resnet18` in un file denominato `resnet18.zip`.
+ Nella pagina **Create a Machine Learning resource (Crea una risorsa Machine Learning)**, per **Resource name (Nome risorsa)**, immetti **resnet18\$1model**.
+ Caricare il file `resnet18.zip`
1. **Se è in esecuzione in modalità containerizzata**, aggiungi le risorse del dispositivo locale necessarie per concedere l'accesso alla GPU del dispositivo.
**Nota**
Se esegui in modalità non containerizzata, AWS IoT Greengrass puoi accedere alla GPU del dispositivo senza configurare le risorse del dispositivo.
1. **Nella pagina di configurazione del gruppo, scegli la scheda Risorse.**
1. Nella sezione **Risorse locali**, scegli **Aggiungi risorsa locale**.
1. Definisci ogni risorsa:
+ Per **Resource name (Nome risorsa)** e **Device path (Percorso dispositivo)**, utilizza i valori nella tabella seguente. Crea una risorsa del dispositivo per ogni riga nella tabella.
+ Per **Resource type (Tipo di risorsa)**, scegli **Device (Dispositivo)**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file****, scegli Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-dlc-console.html)
1. **Se è in esecuzione in modalità containerizzata**, aggiungi la seguente risorsa di volume locale per concedere l'accesso alla fotocamera del tuo dispositivo. Segui la procedura riportata in [Passaggio 5: aggiungere una risorsa modello ottimizzata per SageMaker AI NEO al gruppo Greengrass](#ml-console-dlc-add-resources).
**Nota**
Se si esegue in modalità non containerizzata, è AWS IoT Greengrass possibile accedere alla fotocamera del dispositivo senza configurare le risorse del dispositivo.
+ Per **Resource type (Tipo di risorsa)**, scegli **Volume**.
+ Per il **proprietario del gruppo di sistema e le autorizzazioni di accesso ai file**, scegli **Aggiungi automaticamente le autorizzazioni del file system del gruppo di sistema proprietario della risorsa**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/greengrass/v1/developerguide/ml-dlc-console.html)
1. Aggiornare le sottoscrizioni di gruppo per utilizzare la directory corretta. Segui la procedura descritta in [Fase 7: aggiunta di sottoscrizioni al gruppo Greengrass](#ml-console-dlc-add-subscription), con i seguenti aggiornamenti:
+ Per il primo filtro di argomenti, immettere **/resnet-18/predictions**.
+ Per il secondo filtro di argomenti, immettere **/resnet-18/test**.
1. Aggiornare le sottoscrizioni di test per utilizzare la directory corretta. Segui la procedura descritta in [Esecuzione del test dell'esempio di inferenza](#ml-console-dlc-test-app), con i seguenti aggiornamenti:
+ Per **Abbonamenti**, scegli **Sottoscrivi a un argomento.** Per **Argomento sottoscrizione**, immetti **/resnet-18/predictions**.
+ Nella pagina `/resnet-18/predictions`, specificare l'argomento `/resnet-18/test` in cui effettuare la pubblicazione.
## Risoluzione dei problemi di AWS IoT Greengrass inferenza ML
Se il test non viene completato correttamente, puoi provare a eseguire la procedura di risoluzione dei problemi riportata di seguito. Esegui i comandi nel terminale Raspberry Pi.
### Controlla i log degli errori
1. Passare all'utente root e navigare alla directory `log`. L'accesso ai AWS IoT Greengrass log richiede i permessi di root.
```
sudo su
cd /greengrass/ggc/var/log
```
1. Verifica la presenza `runtime.log` di eventuali errori.
```
cat system/runtime.log | grep 'ERROR'
```
Puoi anche cercare eventuali errori nel registro delle funzioni Lambda definito dall'utente:
```
cat user/your-region/your-account-id/lambda-function-name.log | grep 'ERROR'
```
Per ulteriori informazioni, consulta [Risoluzione dei problemi con i log](gg-troubleshooting.md#troubleshooting-logs).
### Verifica che la funzione Lambda sia implementata correttamente
1. Elenca il contenuto della Lambda distribuita nella `/lambda` directory. Prima di eseguire il comando, sostituisci i valori dei segnaposti.
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. Verifica che la directory contenga gli stessi file inclusi nel pacchetto di distribuzione `optimizedImageClassification.zip` caricato in [Fase 3: Creare una funzione Lambda di inferenza](#ml-console-dlc-create-lambda).
Assicurati inoltre che i file `.py` e le dipendenze si trovino nella root della directory.
### Verifica che il modello di inferenza sia stato distribuito correttamente
1. Trova il numero di identificazione del processo (PID) del processo di runtime Lambda:
```
ps aux | grep lambda-function-name
```
Nell'output, il PID appare nella seconda colonna della riga per il processo di runtime Lambda.
1. Inserisci lo spazio dei nomi di runtime Lambda. Assicurati di sostituire il *pid* valore segnaposto prima di eseguire il comando.
**Nota**
Questa directory e il suo contenuto si trovano nello spazio dei nomi di runtime Lambda, quindi non sono visibili in un normale spazio dei nomi Linux.
```
sudo nsenter -t pid -m /bin/bash
```
1. Elenca i contenuti della directory locale specificata per la risorsa ML.
**Nota**
Se il percorso della risorsa ML è diverso da `ml_model`, dovrai sostituirlo qui.
```
cd /ml_model
ls -ls
```
Dovrebbero essere visualizzati i seguenti file:
```
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
```
### La funzione Lambda non trova `/dev/dri/renderD128`
Questa situazione può verificarsi se OpenCL non è in grado di connettersi ai dispositivi GPU necessari. È necessario creare risorse di dispositivo per i dispositivi necessari per la funzione Lambda.
## Fasi successive
Esplorare altri modelli ottimizzati. Per informazioni, consulta la [documentazione di SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).