Aviso de fim do suporte: em 7 de outubro de 2026, AWS o suporte para o. AWS IoT Greengrass Version 1 Depois de 7 de outubro de 2026, você não poderá mais acessar os AWS IoT Greengrass V1 recursos. Para obter mais informações, visite [Migrar de AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Executar a inferência de machine learning
Esse recurso está disponível para AWS IoT Greengrass Core v1.6 ou posterior.
Com AWS IoT Greengrass, você pode realizar inferência de aprendizado de máquina (ML) na borda em dados gerados localmente usando modelos treinados na nuvem. Você se beneficia da baixa latência e da redução de custos na execução da inferência local, e ainda aproveita a capacidade de computação em nuvem para modelos de treinamento e processamento complexo.
Para começar a realizar a inferência local, consulte [Como configurar a inferência de aprendizado de máquina usando o Console de gerenciamento da AWS](ml-console.md).
## Como a inferência de AWS IoT Greengrass ML funciona
Você pode treinar seus modelos de inferência em qualquer lugar, implantá-los localmente como *recursos de machine learning* em um grupo do Greengrass e, em seguida, acessá-los a partir das funções do Lambda do Greengrass. Por exemplo, você pode criar e treinar modelos de aprendizado profundo em [SageMaker IA](https://console.aws.amazon.com/sagemaker) e implantá-los em seu núcleo do Greengrass. Em seguida, suas funções do Lambda poderão usar os modelos locais para realizar inferências nos dispositivos conectados e enviar novos dados de treinamento de volta para a nuvem.
O diagrama a seguir mostra o fluxo de trabalho AWS IoT Greengrass de inferência de ML.
![\[Componentes do fluxo de trabalho de machine learning e o fluxo de informações entre o dispositivo de núcleo, o serviço do AWS IoT Greengrass e os modelos treinados na nuvem.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/ml-inference/diagram-ml-overview.png)
AWS IoT Greengrass A inferência de ML simplifica cada etapa do fluxo de trabalho de ML, incluindo:
+ Criação e implantação de protótipos de estrutura do ML.
+ Acesso aos modelos treinados em nuvem e implementação em dispositivos de núcleo do Greengrass.
+ Criação de aplicativos de inferência que podem acessar aceleradores de hardware (como GPUs e FPGAs) como recursos [locais](access-local-resources.md).
## Recursos de machine learning
Os recursos de aprendizado de máquina representam modelos de inferência treinados na nuvem que são implantados em um núcleo. AWS IoT Greengrass Para implantar recursos de machine learning, primeiro adicione os recursos a um grupo do Greengrass e defina como as funções do Lambda no grupo poderão acessá-los. Durante a implantação em grupo, AWS IoT Greengrass recupera os pacotes do modelo de origem da nuvem e os extrai para diretórios dentro do namespace de tempo de execução do Lambda. Em seguida, as funções do Lambda do Greengrass usam os modelos implantados localmente para realizar a inferência.
Para atualizar um modelo implantado localmente, primeiro atualize o modelo de origem (na nuvem) que corresponde ao recurso de machine learning e, em seguida, implemente o grupo. Durante a implantação, o AWS IoT Greengrass verifica se há alterações na origem. Se forem detectadas alterações, AWS IoT Greengrass atualiza o modelo local.
### Fontes de modelo compatíveis
AWS IoT Greengrass suporta fontes de modelos de SageMaker IA e Amazon S3 para recursos de aprendizado de máquina.
Os requisitos a seguir se aplicam a fontes de modelo:
+ Os buckets do S3 que armazenam suas fontes de modelos de SageMaker IA e Amazon S3 não devem ser criptografados usando SSE-C. Para buckets que usam criptografia do lado do servidor, a inferência de AWS IoT Greengrass ML atualmente oferece suporte somente às opções de criptografia SSE-S3 ou SSE-KMS. Para obter mais informações sobre as opções criptografia no lado do servidor, consulte [Protegendo dados usando criptografia no lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html) no *Guia do usuário do Amazon Simple Storage Service*.
+ Os nomes dos buckets do S3 que armazenam suas fontes de modelos de SageMaker IA e Amazon S3 não devem incluir pontos (). `.` Para obter mais informações, consulte a regra sobre como usar buckets hospedados virtualmente com SSL em [Regras para nomenclatura de buckets](https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html#bucketnamingrules) no *Guia do usuário do Amazon Simple Storage Service*.
+ [O Região da AWS suporte em nível de serviço deve estar disponível tanto para a IA [AWS IoT Greengrass](https://docs.aws.amazon.com/general/latest/gr/greengrass.html)quanto SageMaker para a IA.](https://docs.aws.amazon.com/general/latest/gr/sagemaker.html) Atualmente, AWS IoT Greengrass oferece suporte a modelos de SageMaker IA nas seguintes regiões:
+ Leste dos EUA (Ohio)
+ Leste dos EUA (N. da Virgínia)
+ Oeste dos EUA (Oregon)
+ Ásia-Pacífico (Mumbai)
+ Ásia-Pacífico (Seul)
+ Ásia-Pacífico (Singapura)
+ Ásia-Pacífico (Sydney)
+ Ásia-Pacífico (Tóquio)
+ Europa (Frankfurt)
+ Europa (Irlanda)
+ Europa (Londres)
+ AWS IoT Greengrass deve ter `read` permissão para acessar a fonte do modelo, conforme descrito nas seções a seguir.
**SageMaker AI**
AWS IoT Greengrass oferece suporte a modelos que são salvos como trabalhos de treinamento de SageMaker IA. SageMaker A IA é um serviço de ML totalmente gerenciado que você pode usar para criar e treinar modelos usando algoritmos integrados ou personalizados. Para obter mais informações, consulte [O que é SageMaker IA?](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) no *Guia do desenvolvedor de SageMaker IA*.
Se você configurou seu ambiente de SageMaker IA [criando um bucket](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-config-permissions.html) cujo nome contém`sagemaker`, então AWS IoT Greengrass tem permissão suficiente para acessar seus trabalhos de treinamento de SageMaker IA. A política gerenciada `AWSGreengrassResourceAccessRolePolicy` permite o acesso a buckets cujo nome contém a string `sagemaker`. Esta política é anexada à [função de serviço do Greengrass](service-role.md).
Caso contrário, você deverá conceder AWS IoT Greengrass `read` permissão ao bucket em que seu trabalho de treinamento está armazenado. Para fazer isso, incorpore a seguinte política em linha no perfil de serviço. Você pode listar vários buckets ARNs.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
**Amazon S3**
AWS IoT Greengrass suporta modelos que são armazenados no Amazon S3 como `tar.gz` arquivos. `.zip`
**Para permitir o acesso AWS IoT Greengrass aos modelos armazenados nos buckets do Amazon S3, você deve conceder AWS IoT Greengrass `read` permissão para acessar os buckets fazendo o seguinte:**
+ Armazene seu modelo em um recipiente cujo nome contém `greengrass`.
A política gerenciada `AWSGreengrassResourceAccessRolePolicy` permite o acesso a buckets cujo nome contém a string `greengrass`. Esta política é anexada à [função de serviço do Greengrass](service-role.md).
+ Incorpore uma política inline na função de serviço do Greengrass.
Se o nome do seu intervalo não contiver `greengrass`, adicione a seguinte política inline à função de serviço. Você pode listar vários buckets ARNs.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
}
]
}
```
------
Para mais informações, consulte [Incorporando políticas inline](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console) no *Guia do usuário do IAM*.
## Requisitos
Os requisitos a seguir se aplicam para criar e usar recursos de machine learning:
+ Você deve estar usando o AWS IoT Greengrass Core v1.6 ou posterior.
+ As funções do Lambda definidas pela usuário podem realizar operações `read` ou `read and write` no recurso. Permissões para outras operações não estão disponíveis. O modo de conteinerização das funções afiliadas do Lambda determina as permissões de acesso são definidas. Para obter mais informações, consulte [Acesse os recursos de machine learning das funções do Lambda](access-ml-resources.md).
+ Você precisa fornecer o caminho completo do recurso no sistema operacional do dispositivo de núcleo.
+ Um nome de recurso ou ID tem um comprimento máximo de 128 caracteres e deve usar o padrão `[a-zA-Z0-9:_-]+`.
## Tempos de execução e bibliotecas para inferência de ML
Você pode usar os seguintes tempos de execução e bibliotecas de ML com AWS IoT Greengrass.
+ [Tempo de execução de aprendizado profundo do Amazon SageMaker Neo](#dlc-optimize-info)
+ Apache MXNet
+ TensorFlow
Esses tempos de execução e bibliotecas podem ser instalados nas plataformas NVIDIA Jetson TX2, Intel Atom e Raspberry Pi. Para baixar as informações, consulte [Bibliotecas e tempos de execução de machine learning compatíveis](what-is-gg.md#ml-runtimes-libs). Você pode instalá-los diretamente no dispositivo principal.
Leia as seguintes informações sobre compatibilidade e limitações.
### SageMaker Tempo de execução de aprendizado profundo AI Neo
Você pode usar o tempo de execução de aprendizado profundo SageMaker AI Neo para realizar inferências com modelos otimizados de aprendizado de máquina em seus AWS IoT Greengrass dispositivos. Esses modelos são otimizados usando o compilador de aprendizado profundo SageMaker AI Neo para melhorar as velocidades de previsão de inferência de aprendizado de máquina. Para obter mais informações sobre otimização de modelos em SageMaker IA, consulte a [documentação do SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
**nota**
No momento, é possível otimizar modelos de machine learning usando o compilador de aprendizado profundo do Neo somente em Regiões específicas da Amazon Web Services. No entanto, você pode usar o tempo de execução de aprendizado profundo Neo com modelos otimizados em cada um Região da AWS onde o AWS IoT Greengrass núcleo é suportado. Para obter informações, consulte [Como configurar a inferência otimizada de Machine Learning](ml-dlc-console.md).
### MXNet versionamento
Atualmente, o Apache MXNet não garante compatibilidade futura, portanto, os modelos que você treina usando versões posteriores da estrutura podem não funcionar corretamente nas versões anteriores da estrutura. Para evitar conflitos entre os estágios de treinamento e fornecimento de modelos e fornecer uma end-to-end experiência consistente, use a mesma versão da MXNet estrutura em ambos os estágios.
### MXNet no Raspberry Pi
As funções do Greengrass Lambda que acessam MXNet modelos locais devem definir a seguinte variável de ambiente:
```
MXNET_ENGINE_TYPE=NativeEngine
```
É possível definir a variável de ambiente no código da função ou adicioná-la à configuração específica do grupo da função. Para um exemplo que a adiciona como uma configuração, consulte esta [etapa](ml-console.md#ml-console-config-lambda).
**nota**
Para uso geral da MXNet estrutura, como executar um exemplo de código de terceiros, a variável de ambiente deve ser configurada no Raspberry Pi.
### TensorFlow limitações de fornecimento de modelos no Raspberry Pi
As recomendações a seguir para melhorar os resultados da inferência são baseadas em nossos testes com as bibliotecas Arm de TensorFlow 32 bits na plataforma Raspberry Pi. Estas recomendações são destinadas apenas para usuários avançados, sem garantias de qualquer tipo.
+ Modelos treinados usando o formato de [ponto de verificação](https://www.tensorflow.org/guide/checkpoint) deve ser "congelado" para o formato de buffer de protocolo antes do fornecimento. Para ver um exemplo, consulte a biblioteca [TensorFlowde modelos de classificação de imagens -Slim](https://github.com/tensorflow/models/tree/master/research/slim).
+ Não use as bibliotecas TF-Estimator e TF-Slim no código de treinamento nem no de inferência. Em vez disso, use o arquivo `.pb` padrão de carregamento do modelo mostrado no exemplo a seguir.
```
graph = tf.Graph()
graph_def = tf.GraphDef()
graph_def.ParseFromString(pb_file.read())
with graph.as_default():
tf.import_graph_def(graph_def)
```
**nota**
Para obter mais informações sobre plataformas suportadas para TensorFlow, consulte [Instalação TensorFlow](https://www.tensorflow.org/install/#installing_from_sources) na TensorFlow documentação.
# Acesse os recursos de machine learning das funções do Lambda
As funções Lambda definidas pelo usuário podem acessar recursos de aprendizado de máquina para executar inferência local no núcleo. AWS IoT Greengrass Um recurso de machine learning consiste no modelo treinado e outros artefatos que são obtidos por download para o dispositivo de núcleo.
Para permitir que uma função do Lambda acesse um recurso de machine learning no núcleo, você deve anexar o recurso à função do Lambda e definir permissões de acesso. O [modo de conteinerização](lambda-group-config.md#lambda-function-containerization) da função do Lambda afiliada (ou *anexada*) determina como você faz isso.
## Acessar as permissões para recursos de machine learning
A partir AWS IoT Greengrass do Core v1.10.0, você pode definir um proprietário de recurso para um recurso de aprendizado de máquina. O proprietário do recurso representa o grupo de sistemas operacionais e as permissões que AWS IoT Greengrass usa para baixar os artefatos do recurso. Se um proprietário do recurso não estiver definido, os artefatos de recurso obtidos por download estarão acessíveis somente na raiz.
+ Se as funções não conteinerizadas do Lambda acessarem um recurso de machine learning, você deve definir um proprietário do recurso, pois não há controle de permissão a partir do contêiner. As funções não conteinerizadas do Lambda podem herdar permissões de proprietário do recurso e usá-las para acessar o recurso.
+ Se apenas funções conteinerizadas do Lambda acessarem o recurso, recomendamos que você use permissões no nível da função em vez de definir um proprietário do recurso.
### Propriedades do proprietário do recurso
Um proprietário do recurso especifica um proprietário do grupo e permissões de proprietário do grupo.
**Proprietário do grupo**. O ID do grupo (GID) de um grupo de SO Linux existente no dispositivo de núcleo. As permissões do grupo são adicionadas ao processo do Lambda. Especificamente, o GID é adicionado ao grupo suplementar da função IDs Lambda.
Se uma função do Lambda no grupo Greengrass estiver configurada para [ser executada](lambda-group-config.md#lambda-access-identity) como o mesmo grupo de SO que o proprietário do recurso de um recurso de machine learning, o recurso deverá ser anexado à função do Lambda. Caso contrário, a implantação falhará porque essa configuração fornece permissões implícitas que a função Lambda pode usar para acessar o recurso AWS IoT Greengrass sem autorização. A verificação de validação da implantação será ignorada se a função do Lambda for executada como raiz (UID=0).
Recomendamos que você use um grupo de SO que não seja usado por outros recursos, funções do Lambda ou arquivos no núcleo do Greengrass. O uso de um grupo de SO compartilhado concede mais permissões de acesso às funções anexadas do Lambda do que elas precisam. Se você usar um grupo de SO compartilhado, uma função do Lambda anexada também deverá ser anexada a todos os recursos de machine learning que usam o grupo de SO compartilhado. Caso contrário, haverá falha na implantação.
**Permissões de proprietário do grupo**. A permissão somente leitura ou leitura e gravação a ser adicionada ao processo do Lambda.
As funções não conteinerizadas do Lambda devem herdar essas permissões de acesso ao recurso. As funções conteinerizadas do Lambda podem herdar essas permissões no nível do recurso ou definir permissões no nível da função. Se elas definirem permissões no nível da função, as permissões deverão ser as mesmas ou mais restritivas do que as permissões no nível do recurso.
A tabela a seguir mostra as configurações de permissão de acesso compatíveis.
------
#### [ GGC v1.10 or later ]
| Propriedade | Se apenas as funções conteinerizadas do Lambda acessarem o recurso | Se qualquer função não conteinerizada do Lambda acessar o recurso |
| --- |--- |--- |
| **Propriedades no nível da função** |
| --- |
| Permissões (leitura/gravação) | Obrigatório, a menos que o recurso defina um proprietário do recurso. Se um proprietário do recurso estiver definido, as permissões no nível da função devem ser as mesmas ou mais restritivas do que as permissões de proprietário do recurso. Se apenas funções conteinerizadas do Lambda acessarem o recurso, recomendamos que você não defina um proprietário do recurso. | **Funções não conteinerizadas do Lambda:** Sem compatibilidade. As funções não conteinerizadas do Lambda devem herdar permissões no nível do recurso. **Funções conteinerizadas do Lambda:** Opcional, mas devem ser as mesmas ou mais restritivas do que as permissões no nível do recurso. |
| **Propriedades no nível do recurso** |
| --- |
| Proprietário do recurso | Opcional (não recomendado). | Obrigatório. |
| Permissões (leitura/gravação) | Opcional (não recomendado). | Obrigatório. |
------
#### [ GGC v1.9 or earlier ]
| Propriedade | Se apenas as funções conteinerizadas do Lambda acessarem o recurso | Se qualquer função não conteinerizada do Lambda acessar o recurso |
| --- |--- |--- |
| **Propriedades no nível da função** |
| --- |
| Permissões (leitura/gravação) | Obrigatório. | Sem compatibilidade. |
| **Propriedades no nível do recurso** |
| --- |
| Proprietário do recurso | Sem compatibilidade. | Sem compatibilidade. |
| Permissões (leitura/gravação) | Sem compatibilidade. | Sem compatibilidade. |
------
**nota**
Quando você usa a AWS IoT Greengrass API para configurar funções e recursos do Lambda, a `ResourceId` propriedade em nível de função também é necessária. A propriedade `ResourceId` anexa o recurso de machine learning à função do Lambda.
## Definição das permissões de acesso às funções do Lambda (console)
No AWS IoT console, você define as permissões de acesso ao configurar um recurso de aprendizado de máquina ou anexar um a uma função Lambda.
**Funções conteinerizadas do Lambda**
Se apenas funções conteinerizadas do Lambda estiverem anexadas ao recurso de machine learning:
+ Selecione **Nenhum grupo de sistema** como proprietário do recurso para o recurso de machine learning. Essa é a configuração recomendada quando apenas funções conteinerizadas do Lambda acessam o recurso de machine learning. Caso contrário, você pode conceder mais permissões de acesso às funções anexadas do Lambda do que elas precisam.
**Funções não conteinerizadas do Lambda** (requer a v1.10 ou posterior do GGC)
Se alguma função não conteinerizada do Lambda estiver anexada ao recurso de machine learning:
+ Especifique o **ID do grupo do sistema (GID)** a ser usado como proprietário do recurso para o recurso de machine learning. Selecione **Specify system group and permissions (Especificar grupo do sistema e permissões)** e insira o GID. Você pode usar o comando `getent group` no dispositivo de núcleo para pesquisar o ID de um grupo de sistemas.
+ Selecione **Acesso somente leitura** ou **Acesso de leitura e gravação** para as **Permissões do grupo de sistemas**.
## Definindo as permissões de acesso para funções do Lambda (API)
Na AWS IoT Greengrass API, você define permissões para recursos de aprendizado de máquina na `ResourceAccessPolicy` propriedade da função Lambda ou na `OwnerSetting` propriedade do recurso.
**Funções conteinerizadas do Lambda**
Se apenas funções conteinerizadas do Lambda estiverem anexadas ao recurso de machine learning:
+ Para funções conteinerizadas do Lambda, defina permissões de acesso na propriedade `Permission` da propriedade `ResourceAccessPolicies`. Por exemplo:
```
"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
}
}
]
```
+ Para recursos de machine learning, omita a propriedade `OwnerSetting`. Por exemplo:
```
"Resources": [
{
"Id": "my-resource-id",
"Name": "my-resource-name",
"ResourceDataContainer": {
"S3MachineLearningModelResourceData": {
"DestinationPath": "/local-destination-path",
"S3Uri": "s3://uri-to-resource-package"
}
}
}
]
```
Essa é a configuração recomendada quando apenas funções conteinerizadas do Lambda acessam o recurso de machine learning. Caso contrário, você pode conceder mais permissões de acesso às funções anexadas do Lambda do que elas precisam.
**Funções não conteinerizadas do Lambda** (requer a v1.10 ou posterior do GGC)
Se alguma função não conteinerizada do Lambda estiver anexada ao recurso de machine learning:
+ Para funções não conteinerizadas do Lambda, omita a propriedade `Permission` em `ResourceAccessPolicies`. Essa configuração é necessária e permite que a função herde a permissão no nível do recurso. Por exemplo:
```
"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
}
}
]
```
+ Para funções conteinerizadas do Lambda que também acessam o recurso de machine learning, omita a propriedade `Permission` em `ResourceAccessPolicies` ou defina uma permissão que seja a mesma ou mais restritiva que a permissão no nível do recurso. Por exemplo:
```
"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
}
}
]
```
+ Para recursos de machine learning, defina a propriedade `OwnerSetting`, incluindo o filho `GroupOwner` e as propriedades `GroupPermission`. Por exemplo:
```
"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"
}
}
}
}
]
```
## Acessando os recursos de machine learning do código de função do Lambda
As funções do Lambda definidas pelo usuário usam interfaces de SO específicas da plataforma para acessar recursos de machine learning em um dispositivo de núcleo.
------
#### [ GGC v1.10 or later ]
Para funções conteinerizadas do Lambda, o recurso é montado dentro do contêiner Greengrass e disponibilizado no caminho de destino local definido para o recurso. Para funções conteinerizadas do Lambda, o recurso apresenta um symblink em um diretório de trabalho específico do Lambda e passado para a variável de ambiente `AWS_GG_RESOURCE_PREFIX` no processo do Lambda.
Para obter o caminho para os artefatos de um recurso de machine learning obtidos por download, as funções do Lambda acrescentam a variável de ambiente `AWS_GG_RESOURCE_PREFIX` ao caminho de destino local definido para o recurso. Para funções conteinerizadas do Lambda, o valor retornado é uma barra única (`/`).
```
resourcePath = os.getenv("AWS_GG_RESOURCE_PREFIX") + "/destination-path"
with open(resourcePath, 'r') as f:
# load_model(f)
```
------
#### [ GGC v1.9 or earlier ]
Os artefatos de um recurso de machine learning obtidos por download estão localizados no caminho de destino local definido para o recurso. Apenas funções conteinerizadas do Lambda podem acessar recursos de machine learning no AWS IoT Greengrass Core v1.9 e versões anteriores.
```
resourcePath = "/local-destination-path"
with open(resourcePath, 'r') as f:
# load_model(f)
```
------
A implementação do seu modelo de carregamento depende da sua biblioteca de ML.
## Solução de problemas
Use as informações a seguir para ajudá-lo a solucionar problemas com o acesso aos recursos de machine learning.
**Topics**
+ [MLModelProprietário inválido - GroupOwnerSetting é fornecido no recurso do modelo ML, mas GroupOwner ou não GroupPermission está presente](#nocontainer-lambda-invalid-ml-model-owner)
+ [NoContainer a função não pode configurar a permissão ao anexar recursos do Machine Learning. refere-se ao recurso de aprendizado de máquina com permissão na política de acesso a recursos.](#nocontainer-lambda-invalid-resource-access-policy)
+ [Função se refere ao recurso de Machine Learning sem permissão em ambos ResourceAccessPolicy os recursos OwnerSetting.](#nocontainer-lambda-missing-access-permission)
+ [A função se refere ao recurso de Machine Learning com a permissão\$1 "rw\$1”, enquanto a configuração do proprietário do recurso permite GroupPermission apenas\$1 "ro\$1”.](#container-lambda-invalid-rw-permissions)
+ [NoContainer A função se refere aos recursos do caminho de destino aninhado.](#nocontainer-lambda-nested-destination-path)
+ [O Lambda ganha acesso ao recurso compartilhando o mesmo ID do proprietário do grupo](#lambda-runas-and-resource-owner)
### MLModelProprietário inválido - GroupOwnerSetting é fornecido no recurso do modelo ML, mas GroupOwner ou não GroupPermission está presente
**Solução:** você receberá esse erro se um recurso de aprendizado de máquina contiver o [ResourceDownloadOwnerSetting](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resourcedownloadownersetting.html)objeto, mas o necessário `GroupOwner` ou a `GroupPermission` propriedade não estiverem definidos. Para resolver esse problema, defina a propriedade ausente.
### NoContainer a função não pode configurar a permissão ao anexar recursos do Machine Learning. refere-se ao recurso de aprendizado de máquina com permissão na política de acesso a recursos.
**Solução:** você receberá esse erro se uma função não conteinerizada do Lambda especificar permissões no nível da função para um recurso de machine learning. As funções não conteinerizadas devem herdar permissões das permissões de proprietário do recurso definidas no recurso de machine learning. Para resolver esse problema, selecione [herdar permissões de proprietário do recurso](#non-container-config-console) (console) ou [rremover as permissões da política de acesso aos recursos da função do Lambda](#non-container-config-api) (API) .
### Função se refere ao recurso de Machine Learning sem permissão em ambos ResourceAccessPolicy os recursos OwnerSetting.
**Solução:** você receberá esse erro se as permissões para o recurso de machine learning não estiverem configuradas para a função anexada do Lambda ou para o recurso. Para resolver esse problema, configure as permissões na [ResourceAccessPolicy](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-resourceaccesspolicy.html)propriedade da função Lambda ou na [OwnerSetting](https://docs.aws.amazon.com/greengrass/v1/apireference/definitions-ownersetting.html)propriedade do recurso.
### A função se refere ao recurso de Machine Learning com a permissão\$1 "rw\$1”, enquanto a configuração do proprietário do recurso permite GroupPermission apenas\$1 "ro\$1”.
**Solução:** você receberá esse erro se as permissões de acesso definidas para a função anexada do Lambda excederem as permissões de proprietário do recurso definidas para o recurso de machine learning. Para resolver esse problema, defina permissões mais restritivas para a função do Lambda ou permissões menos restritivas para o proprietário do recurso.
### NoContainer A função se refere aos recursos do caminho de destino aninhado.
**Solução:** você receberá esse erro se vários recursos de machine learning anexados a uma função não conteinerizada do Lambda utilizarem o mesmo caminho de destino ou um caminho de destino aninhado. Para resolver esse problema, especifique caminhos de destino separados para os recursos.
### O Lambda ganha acesso ao recurso compartilhando o mesmo ID do proprietário do grupo
**Solução:** você receberá esse erro em `runtime.log` se o mesmo grupo de sistemas operacionais for especificado como a identidade da função do Lambda [Executar como](lambda-group-config.md#lambda-access-identity) e o [proprietário do recurso](#ml-resource-owner) de um recurso de machine learning, mas o recurso não estiver vinculado à função do Lambda. Essa configuração dá à função Lambda permissões implícitas que ela pode usar para acessar o recurso sem autorização. AWS IoT Greengrass
Para resolver esse problema, use um grupo de SO diferente para uma das propriedades ou anexe o recurso de machine learning à função do Lambda.
## Consulte também
+ [Executar a inferência de machine learning](ml-inference.md)
+ [Como configurar a inferência de aprendizado de máquina usando o Console de gerenciamento da AWS](ml-console.md)
+ [Como configurar a inferência otimizada de aprendizado de máquina usando o Console de gerenciamento da AWS](ml-dlc-console.md)
+ [AWS IoT Greengrass Version 1 API Reference](https://docs.aws.amazon.com/greengrass/v1/apireference/api-doc.html)
# Como configurar a inferência de aprendizado de máquina usando o Console de gerenciamento da AWS
Para seguir as etapas deste tutorial, você precisa do AWS IoT Greengrass Core v1.10 ou posterior.
Você pode realizar inferência de machine learning (ML) localmente em um dispositivo de núcleo do Greengrass usando dados gerados localmente. Para obter mais informações, inclusive sobre os requisitos e restrições, consulte [Executar a inferência de machine learning](ml-inference.md).
Este tutorial descreve como usar o Console de gerenciamento da AWS para configurar um grupo do Greengrass para executar um aplicativo de inferência Lambda que reconhece imagens de uma câmera localmente, sem enviar dados para a nuvem. O aplicativo de inferência acessa o módulo da câmera em um Raspberry Pi e executa a inferência usando o modelo de código aberto. [SqueezeNet](https://github.com/DeepScale/SqueezeNet)
O tutorial contém as seguintes etapas de nível elevado:
1. [Configurar o Raspberry Pi](#config-raspberry-pi)
1. [Instale a MXNet estrutura](#install-mxnet)
1. [Criar um pacote de modelo](#package-ml-model)
1. [Crie e publique uma função do Lambda](#ml-console-create-lambda)
1. [Adicionar a função do Lambda ao grupo](#ml-console-config-lambda)
1. [Adicionar recursos ao grupo](#ml-console-add-resources)
1. [Adicionar uma assinatura ao grupo](#ml-console-add-subscription)
1. [Implantar o grupo](#ml-console-deploy-group)
1. [Testar o aplicativo](#ml-console-test-app)
## Pré-requisitos
Para concluir este tutorial, é necessário:
+ Raspberry Pi 4 Modelo B, ou Raspberry Pi 3 Modelo B/B\$1, instalado e configurado para uso com. AWS IoT Greengrass Para configurar seu Raspberry Pi com o AWS IoT Greengrass, execute o script [Greengrass Device Setup](quick-start.md) ou conclua o [Módulo 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) e o [Módulo 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) do [Começando com AWS IoT Greengrass](gg-gs.md).
**nota**
O Raspberry Pi pode exigir uma [fonte de alimentação](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/) de 2,5 A para executar as estruturas de aprendizado profundo que normalmente são usadas para classificação de imagens. Uma fonte de alimentação com uma classificação mais baixa pode fazer com que o dispositivo seja reinicializado.
+ [Módulo de câmera Raspberry Pi V2 - 8 megapixels, 1080 p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Para obter informações sobre como configurar a câmera, consulte [Conectar a câmera](https://www.raspberrypi.org/documentation/usage/camera/) na documentação do Raspberry Pi.
+ Um grupo do Greengrass e um núcleo do Greengrass. Para obter informações sobre como criar um grupo ou núcleo do Greengrass, consulte [Começando com AWS IoT Greengrass](gg-gs.md).
**nota**
Este tutorial usa um Raspberry Pi, mas AWS IoT Greengrass oferece suporte a outras plataformas, como [Intel Atom](#atom-lambda-config) e [NVIDIA](#jetson-lambda-config) Jetson. TX2 No exemplo do Jetson TX2, você pode usar imagens estáticas em vez de imagens transmitidas de uma câmera. Se estiver usando o TX2 exemplo do Jetson, talvez seja necessário instalar o Python 3.6 em vez do Python 3.7. Para obter informações sobre como configurar seu dispositivo para que você possa instalar o software AWS IoT Greengrass Core, consulte[Configurar outros dispositivos](setup-filter.other.md).
Para plataformas de terceiros que AWS IoT Greengrass não oferecem suporte, você deve executar sua função Lambda no modo não conteinerizado. Para executar no modo sem contêiner, você deve executar sua função do Lambda como root. Para obter mais informações, consulte [Considerações ao escolher a conteinerização de função do Lambda](lambda-group-config.md#lambda-containerization-considerations) e [Definir a identidade de acesso padrão para as funções do Lambda em um grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
## Etapa 1: Configurar o Raspberry Pi
Nesta etapa, instale as atualizações no sistema operacional Raspbian, instale o software do módulo da câmera e as dependências do Python e ative a interface da câmera.
Execute os seguintes comandos no seu terminal do Raspberry Pi.
1. Instale as atualizações no Raspbian.
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. Instale a interface do `picamera` para o módulo da câmera e outras bibliotecas do Python que são necessárias para este tutorial.
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
Valide a instalação:
+ Verifique se a instalação do Python 3.7 inclui o pip.
```
python3 -m pip
```
Se o pip não estiver instalado, faça download dele no [site do pip](https://pip.pypa.io/en/stable/installing/) e execute o seguinte comando.
```
python3 get-pip.py
```
+ Verifique se a versão do Python é 3.7 ou superior.
```
python3 --version
```
Se a saída listar uma versão anterior, execute o seguinte comando.
```
sudo apt-get install -y python3.7-dev
```
+ Verifique se o Setuptools e Picamera foram instalados com êxito.
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Se a saída não contiver erros, a validação será bem-sucedida.
**nota**
Se o Python executável instalado no dispositivo for o `python3.7`, use `python3.7` em vez de `python3` para os comandos neste tutorial. Verifique se a instalação do pip mapeia para a versão correta do `python3` ou `python3.7` para evitar erros de dependência.
1. Reinicie o Raspberry Pi.
```
sudo reboot
```
1. Abra a ferramenta de configuração do Raspberry Pi.
```
sudo raspi-config
```
1. Use as setas do teclado para abrir **Interfacing Options** e habilitar a interface da câmera. Se solicitado, permita que o dispositivo seja reinicializado.
1. Use o seguinte comando para testar a configuração da câmera.
```
raspistill -v -o test.jpg
```
Isso abre uma janela de visualização no Raspberry Pi, salva uma imagem chamada `test.jpg` no seu diretório atual e exibe informações sobre a câmera no terminal do Raspberry Pi.
## Etapa 2: instalar a MXNet estrutura
Nesta etapa, instale MXNet bibliotecas no seu Raspberry Pi.
1. Inicie sessão no seu Raspberry Pi remotamente.
```
ssh pi@your-device-ip-address
```
1. Abra a MXNet documentação, abra [Instalação MXNet](https://mxnet.apache.org/get_started/?) e siga as instruções para instalar MXNet no dispositivo.
**nota**
Recomendamos instalar a versão 1.5.0 e compilar a MXNet partir do código-fonte para este tutorial para evitar conflitos de dispositivos.
1. Depois de instalar MXNet, valide a seguinte configuração:
+ Certifique-se de que a conta `ggc_user` do sistema possa usar a MXNet estrutura.
```
sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
+ Verifique se NumPy está instalado.
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## Etapa 3: criar um pacote de MXNet modelo
Nesta etapa, crie um pacote de modelo que contenha uma amostra de MXNet modelo pré-treinado para ser carregada no Amazon Simple Storage Service (Amazon S3). AWS IoT Greengrass pode usar um pacote de modelo do Amazon S3, desde que você use o formato tar.gz ou zip.
1. No seu computador, baixe a MXNet amostra do Raspberry Pi em. [Exemplos de machine learning](what-is-gg.md#gg-ml-samples)
1. Não descompacte o arquivo `mxnet-py3-armv7l.tar.gz` obtido por download.
1. Navegue até o diretório `squeezenet`.
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/models/squeezenet
```
O arquivo `squeezenet.zip` neste diretório é o pacote de modelo. Ele contém artefatos de modelo de código SqueezeNet aberto para um modelo de classificação de imagens. Posteriormente, esse pacote de modelo é carregado no Amazon S3.
## Etapa 4: Crie e publique uma função do Lambda
Nesta etapa, crie um pacote de implantação da função do Lambda e uma função do Lambda. Depois, publique uma versão da função e crie um alias.
Primeiro, crie o pacote de implantação da função do Lambda.
1. No computador, navegue até o diretório `examples` no pacote de exemplo que você descompactou em [Etapa 3: criar um pacote de MXNet modelo](#package-ml-model).
```
cd path-to-downloaded-sample/mxnet-py3-armv7l/examples
```
O diretório `examples` contém código de função e dependências.
+ O `greengrassObjectClassification.py` é o código de inferência usado neste tutorial. Você pode usar esse código como modelo para criar sua própria função de inferência.
+ `greengrasssdk` é a versão 1.5.0 do SDK do AWS IoT Greengrass Core para Python.
**nota**
Se uma nova versão estiver disponível, você poderá fazer download dela e atualizar a versão do SDK no seu pacote de implantação. Para obter mais informações, consulte [AWS IoT Greengrass Core SDK para GitHub Python on](https://github.com/aws/aws-greengrass-core-sdk-python/).
1. Compacte o conteúdo do diretório `examples` em um arquivo chamado `greengrassObjectClassification.zip`. Esse é o pacote de implantação.
```
zip -r greengrassObjectClassification.zip .
```
**nota**
Verifique se os arquivos `.py` e as dependências estão na raiz do diretório.
Depois, crie a função do Lambda .
1. No AWS IoT console, escolha **Funções** e **Criar função**.
1. Selecione **Criar do zero** e use os valores a seguir para criar a função:
+ Em **Function name** (Nome da função), insira **greengrassObjectClassification**.
+ Em **Runtime (Tempo de execução)**, selecione **Python 3.7**.
Em **Permissões**, mantenha a configuração padrão. Isso cria uma função de execução que concede permissões básicas do Lambda. Essa função não é usada por AWS IoT Greengrass.
1. Selecione **Criar função**.
Agora, carregue o seu pacote de implantação da função do Lambda e registre o manipulador.
1. Selecione sua função do Lambda e carregue seu pacote de implantação da função do Lambda.
1. Na guia **Código**, em **Fonte do código**, selecione **Fazer upload a partir de**. No menu suspenso, selecione o **arquivo .zip**.
![\[O menu suspenso Fazer upload a partir de com o arquivo .zip destacado.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. Selecione **Upload** e, em seguida, selecione seu pacote de implantação `greengrassObjectClassification.zip`. Selecione **Salvar**.
1. Na guia **Código** da função, em **Configurações de runtime**, selecione **Editar** e insira os valores a seguir.
+ Em **Runtime (Tempo de execução)**, selecione **Python 3.7**.
+ Em **Handler (Manipulador)**, insira **greengrassObjectClassification.function\$1handler**.
Selecione **Salvar**.
Em seguida, publique a primeira versão da sua função do Lambda. Em seguida, crie um [alias para a versão](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html).
**nota**
Os grupos do Greengrass podem fazer referência a uma função do Lambda por alias (recomendado) ou por versão. Usar um alias facilita o gerenciamento de atualizações de código porque você não precisa alterar a tabela de assinaturas nem a definição do grupo ao atualizar a função do código. Em vez disso, você pode simplesmente apontar o alias para a nova versão da função.
1. No menu **Actions**, selecione **Publish new version**.
![\[A opção Publish new version (Publicar nova versão) no menu Actions (Ações).\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/ml-inference/lambda-publish-version.png)
1. Em **Version description (Descrição da versão)**, insira **First version** e, em seguida, selecione **Publish (Publicar)**.
1. Na página de configuração **greengrassObjectClassification: 1**, no menu **Ações**, escolha **Criar alias**.
![\[A opção Create alias (Criar alias) no menu Actions (Ações).\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/ml-inference/lambda-create-alias.png)
1. Na página **Create a new alias**, use os seguintes valores:
+ Em **Nome**, digite **mlTest**.
+ Em **Version (Versão)**, insira **1**.
**nota**
AWS IoT Greengrass **não oferece suporte a aliases Lambda para as versões \$1LATEST.**
1. Selecione **Salvar**.
Agora, adicione a função do Lambda ao seu grupo do Greengrass.
## Etapa 5: adicionar a função do Lambda ao grupo do Greengrass
Nesta etapa, adicione a função do Lambda ao grupo e configura o ciclo de vida e as variáveis de ambiente.
Primeiro, adicione a função do Lambda ao seu grupo do Greengrass.
1. No painel de navegação do AWS IoT console, em **Gerenciar**, expanda dispositivos **Greengrass** e **escolha Grupos (**V1).
1. Na página de configuração do grupo, selecione a guia **Funções do Lambda**.
1. Na seção **Minhas funções do Lambda**, selecione **Adicionar**.
1. Para a **função Lambda, escolha**. **greengrassObjectClassification**
1. Para a **Versão da função do Lambda**, selecione **Alias:mlTest**.
Em seguida, configure o ciclo de vida e as variáveis de ambiente da função do Lambda.
1. Na seção **Configuração da função do Lambda**, faça as atualizações a seguir.
**nota**
Recomendamos que você execute sua função do Lambda sem conteinerização, a menos que seu caso de negócios faça essa exigência. Isso ajuda a habilitar o acesso à GPU e à câmera do seu dispositivo sem configurar os recursos do dispositivo. Se você executa sem conteinerização, também deve conceder acesso root às suas funções do Lambda AWS IoT Greengrass .
1. **Para executar sem conteinerização:**
+ Para **Usuário e grupo do sistema**, selecione **Another user ID/group ID**. Para **ID de usuário do sistema**, insira **0**. Para **ID do grupo do sistema**, insira **0**.
Isso permite que sua função do Lambda seja executada como root. Para obter mais informações sobre como executar como raiz, consulte [Definir a identidade de acesso padrão para as funções do Lambda em um grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**dica**
Você também deve atualizar seu arquivo `config.json` para conceder acesso root à sua função do Lambda. Para o procedimento, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root).
+ Para **conteinerização da função do Lambda**, selecione **Sem contêiner**.
Para obter mais informações sobre como executar sem conteinerização, consulte [Considerações ao escolher a conteinerização de função do Lambda](lambda-group-config.md#lambda-containerization-considerations).
+ Em **Timeout (Tempo limite)**, insira **10 seconds**.
+ Para **Fixado**, selecione **Verdadeiro**.
Para obter mais informações, consulte [Configuração do ciclo de vida das funções do Lambda do Greengrass](lambda-functions.md#lambda-lifecycle).
1. **Em vez disso, para executar no modo conteinerizado:**
**nota**
Não recomendamos a execução no modo conteinerizado, a menos que seu caso de negócios faça essa exigência.
+ Para **Usuário e grupo do sistema**, selecione **Usar padrão de grupo**.
+ Para **Conteinerização da função do Lambda**, selecione **Usar padrão de grupo**.
+ Em **Memory limit (Limite de memória)**, insira **96 MB**.
+ Em **Timeout (Tempo limite)**, insira **10 seconds**.
+ Para **Fixado**, selecione **Verdadeiro**.
Para obter mais informações, consulte [Configuração do ciclo de vida das funções do Lambda do Greengrass](lambda-functions.md#lambda-lifecycle).
1. Em **Environment variables (Variáveis de ambiente)**, crie um par de chave/valor. Um par de valores-chave é exigido por funções que interagem com MXNet modelos em um Raspberry Pi.
Na chave, use MXNET\$1ENGINE\$1TYPE. Para o valor, use NaiveEngine.
**nota**
Se preferir, nas suas próprias funções do Lambda definidas pelo usuário, é possível definir a variável de ambiente no código da função.
1. Mantenha os valores padrão para todas as outras propriedades e selecione **Adicionar função do Lambda**.
## Etapa 6: Adicionar recursos ao grupo do Greengrass
Nesta etapa, crie recursos para o módulo da câmera e o modelo de inferência de ML e afilie os recursos com a função do Lambda. Isso possibilita que a função do Lambda acesse os recursos no dispositivo básico.
**nota**
Se você executar no modo não conteinerizado, AWS IoT Greengrass poderá acessar a GPU e a câmera do dispositivo sem configurar esses recursos do dispositivo.
Primeiro, crie dois recursos de dispositivos locais para a câmera: um para memória compartilhada e outro para a interface do dispositivo. Para obter mais informações sobre acesso a recursos locais, consulte [Acesso aos recursos locais com funções e conectores do Lambda](access-local-resources.md).
1. Na página de configuração do grupo, selecione a guia **Recursos**.
1. Na seção **Recursos locais**, selecione **Adicionar recurso local**.
1. Na página ** Adicionar recurso local**, use os seguintes valores:
+ Em **Resource Name (Nome do recurso)**, insira **videoCoreSharedMemory**.
+ Em **Resource type**, selecione **Device**.
+ Em **Caminho do dispositivo local**, insira **/dev/vcsm**.
O caminho do dispositivo é o caminho absoluto local do recurso do dispositivo. Este caminho só pode se referir a um dispositivo de caractere ou dispositivo de blocos em `/dev`.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
A opção **Proprietário do grupo do sistema e permissões de acesso ao arquivo** permite conceder permissões adicionais de acesso a arquivos para o processo do Lambda. Para obter mais informações, consulte [Permissão de acesso a arquivo do proprietário do grupo](access-local-resources.md#lra-group-owner).
1. Em seguida, você adiciona um recurso de dispositivo local para a interface da câmera.
1. Selecione **Adicionar recurso local**.
1. Na página **Adicionar recurso local**, use os seguintes valores:
+ Em **Resource Name (Nome do recurso)**, insira **videoCoreInterface**.
+ Em **Resource type**, selecione **Device**.
+ Em **Caminho do dispositivo local**, insira **/dev/vchiq**.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
1. Na parte inferior da página, selecione **Adicionar recurso**.
Agora, adicione o modelo de inferência como um recurso de machine learning. Esta etapa inclui o upload do pacote de modelo `squeezenet.zip` para o Amazon S3.
1. Na guia **Recursos** do seu grupo, na seção **Machine Learning**, selecione **Adicionar recurso de machine learning**.
1. Na página **Adicionar recurso de machine learning**, em **Nome do recurso**, insira **squeezenet\$1model**.
1. Em **Fonte do modelo**, selecione **Usar um modelo armazenado no S3, como um modelo otimizado por meio do compilador de aprendizado profundo**.
1. Para **S3 URI**, insira um caminho em que o bucket do S3 seja salvo.
1. Selecione **Browse S3 (Navegar no S3)**. Isso abre uma nova guia no console do Amazon S3.
1. Na guia do console do Amazon S3, faça upload do arquivo `squeezenet.zip` em um bucket do S3. Para obter informações, consulte [Como carregar arquivos e pastas em um bucket do S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) no *Guia do usuário do Amazon Simple Storage Service*.
**nota**
Para que o bucket do S3 seja acessível, o nome do bucket deve conter a string **greengrass** e o bucket deve estar na mesma região em que você usa o AWS IoT Greengrass. Selecione um nome exclusivo (como **greengrass-bucket-*user-id*-*epoch-time***). Não use ponto (`.`) no nome do bucket.
1. Na guia AWS IoT Greengrass console, localize e escolha seu bucket do S3. Localize o arquivo `squeezenet.zip` carregado e, em seguida selecione **Select (Selecionar)**. Talvez seja necessário escolher **Refresh (Atualizar)** para atualizar a lista de buckets e arquivos disponíveis.
1. Para **Destination path (Caminho de destino)**, insira **/greengrass-machine-learning/mxnet/squeezenet**.
Este é o destino do modelo local no namespace de runtime do Lambda. Quando você implanta o grupo, AWS IoT Greengrass recupera o pacote do modelo de origem e, em seguida, extrai o conteúdo para o diretório especificado. O exemplo da função do Lambda para este tutorial já está configurado para usar este caminho (na variável `model_path`).
1. Em **Proprietário do grupo do sistema e permissões de acesso ao arquivo**, selecione **Sem grupo do sistema**.
1. Selecione **Adicionar recurso**.
### Usando modelos treinados em SageMaker IA
Este tutorial usa um modelo armazenado no Amazon S3, mas você também pode usar modelos de SageMaker IA com facilidade. O AWS IoT Greengrass console tem integração de SageMaker IA integrada, então você não precisa fazer o upload manual desses modelos para o Amazon S3. Para requisitos e limitações do uso de modelos de SageMaker IA, consulte[Fontes de modelo compatíveis](ml-inference.md#supported-model-sources).
Para usar um modelo de SageMaker IA:
+ Em **Fonte do modelo**, escolha **Usar um modelo treinado em AWS SageMaker IA** e, em seguida, escolha o nome do trabalho de treinamento do modelo.
+ Em **Caminho de destino**, insira o caminho para o diretório em que sua função do Lambda procura o modelo.
## Etapa 7: Adicionar uma assinatura ao grupo do Greengrass
Nesta etapa, adicione uma assinatura ao grupo. Essa assinatura permite que a função Lambda envie resultados de previsão AWS IoT publicando em um tópico do MQTT.
1. Na página de configuração do grupo, selecione a guia **Assinaturas** e, em seguida, **Adicionar assinatura**.
1. Na página de **Detalhes da assinatura**, configure a origem e o destino, da seguinte forma:
1. Em **Tipo de fonte**, escolha **Função Lambda** e, em seguida, escolha. **greengrassObjectClassification**
1. Em **Tipo de destino**, selecione **Serviços** e, em seguida, **IoT Cloud**.
1. Em **Filtro de tópicos**, insira **hello/world** e, em seguida, selecione **Criar assinatura**.
## Etapa 8: Implantar o grupo do Greengrass
Nesta etapa, implante a versão atual da definição do grupo ao dispositivo de núcleo do Greengrass. A definição contém a função do Lambda, recursos e configurações de inscrição que você adicionou.
1. Certifique-se de que o AWS IoT Greengrass núcleo esteja funcionando. Execute os seguintes comandos no seu terminal do Raspberry Pi, conforme necessário.
1. Para verificar se o daemon está em execução:
```
ps aux | grep -E 'greengrass.*daemon'
```
Se a saída contém uma entrada `root` para `/greengrass/ggc/packages/1.11.6/bin/daemon`, o daemon está em execução.
**nota**
A versão no caminho depende da versão do software AWS IoT Greengrass principal que está instalada em seu dispositivo principal.
1. Para iniciar o daemon:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Na página de configuração do grupo, selecione **Implantar**.
![\[A página do grupo com Deployments (Implantações) e Deploy (Implantar) em destaque.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/console-group-deployments-deploy.png)
1. Na guia **Funções do Lambda**, na seção **Funções do sistema Lambda**, selecione **Detector de IP** e, em seguida selecione **Editar**.
1. Na caixa de diálogo **Editar configurações do detector IP**, selecione **Detectar e substituir automaticamente os endpoints do corretor MQTT**.
1. Selecione **Salvar**.
Isso permite que os dispositivos adquiram automaticamente as informações de conectividade para o núcleo, como endereço IP, DNS e o número da porta. A detecção automática é recomendada, mas AWS IoT Greengrass também oferece suporte a endpoints especificados manualmente. Você só é solicitado pelo método de descoberta na primeira vez em que o grupo for implantado.
**nota**
Se solicitado, conceda permissão para criar a função de [serviço do Greengrass](service-role.md) e associá-la à Conta da AWS sua na atual. Região da AWS Essa função permite AWS IoT Greengrass acessar seus recursos em AWS serviços.
A página **Deployments** mostra a data e hora, ID de versão e status da implantação. Quando concluída, o status exibido para a implantação deve ser **Concluída**.
Para obter mais informações sobre implantações, consulte [Implante AWS IoT Greengrass grupos em um AWS IoT Greengrass núcleo](deployments.md). Para obter ajuda sobre a solução de problemas, consulte [Solução de problemas AWS IoT Greengrass](gg-troubleshooting.md).
## Etapa 9: Testar o aplicativo de inferência
Agora você pode verificar se a implementação foi configurada corretamente. Para testar, inscreva-se no tópico `hello/world` e visualize os resultados de previsões publicados pela função do Lambda.
**nota**
Se um monitor estiver conectado ao Raspberry Pi, o feed da câmera ao vivo será exibido em uma janela de visualização.
1. No AWS IoT console, em **Teste**, escolha **Cliente de teste MQTT**.
1. Para **Subscriptions**, use os seguintes valores:
+ No tópico de assinatura, use hello/world.
+ Em **Configuração adicional**, para **Exibição da carga útil do MQTT**, selecione **Exibir cargas úteis como strings**.
1. Selecione **Subscribe**.
Se o teste for bem-sucedido, as mensagens da função do função do Lambda serão exibidas na parte inferior da página. Cada mensagem contém os cinco principais resultados de previsão da imagem, usando o formato: probabilidade, ID da classe prevista e nome da classe correspondente.
![\[A página Subscriptions (Inscrições) mostrando resultados de teste com dados de mensagem.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/ml-inference/prediction-results.png)
### Solução de problemas de inferência AWS IoT Greengrass de ML
Se o teste não for bem-sucedido, você poderá tentar as etapas de solução de problemas a seguir. Execute os comandos no seu terminal Raspberry Pi.
#### Verificar logs de erros
1. Alterne para o usuário raiz e navegue até o diretório `log`. O acesso aos AWS IoT Greengrass registros requer permissões de root.
```
sudo su
cd /greengrass/ggc/var/log
```
1. No diretório `system`, verifique `runtime.log` ou `python_runtime.log`.
No diretório `user/region/account-id`, verifique `greengrassObjectClassification.log`.
Para obter mais informações, consulte [Solução de problemas com logs](gg-troubleshooting.md#troubleshooting-logs).
##### Erro "Unpacking" em runtime.log
Se `runtime.log` contiver um erro semelhante ao seguinte, verifique se o pacote de modelos de origem `tar.gz` tem um diretório pai.
```
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 seu pacote não tiver um diretório pai que contenha os arquivos de modelo, use o comando a seguir para tentar empacotar o modelo novamente:
```
tar -zcvf model.tar.gz ./model
```
Por exemplo:
```
─$ tar -zcvf test.tar.gz ./test
./test
./test/some.file
./test/some.file2
./test/some.file3
```
**nota**
Não inclui caracteres `/*` finais neste comando.
#### Verifique se a função do Lambda é implantada com sucesso
1. Liste o conteúdo do Lambda implementado no diretório `/lambda`. Substitua os valores de espaço reservado antes de executar o comando.
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. Verifique se o diretório contém o mesmo conteúdo do pacote de implantação `greengrassObjectClassification.zip` que você carregou no [Etapa 4: Crie e publique uma função do Lambda](#ml-console-create-lambda).
Verifique se os arquivos `.py` e as dependências estão na raiz do diretório.
#### Verifique se o modelo de inferência é implantado com sucesso
1. Encontre o número de identificação de processo (PID) do runtime do Lambda:
```
ps aux | grep 'lambda-function-name*'
```
Na saída, o PID aparece na segunda coluna da linha para o processo de runtime do Lambda.
1. Digite o namespace de runtime do Lambda. Certifique-se de substituir o *pid* valor do espaço reservado antes de executar o comando.
**nota**
Este diretório e seu conteúdo estão no namespace de runtime do Lambda para que não sejam visíveis em um namespace comum do Linux.
```
sudo nsenter -t pid -m /bin/bash
```
1. Liste o conteúdo do diretório local que você especificou para o recurso de ML.
```
cd /greengrass-machine-learning/mxnet/squeezenet/
ls -ls
```
Você deve ver os arquivos a seguir:
```
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
```
## Próximas etapas
Em seguida, explore outros aplicativos de inferência. AWS IoT Greengrass fornece outras funções do Lambda que você pode usar para testar a inferência local. Você pode encontrar o pacote de exemplos na pasta de bibliotecas pré-compiladas que você obteve por download [Etapa 2: instalar a MXNet estrutura](#install-mxnet).
## Como configurar um Intel Atom
Para executar este tutorial em um dispositivo Intel Atom, você deve fornecer imagens de origem, configurar a função do Lambda e adicionar outro recurso de dispositivo local. Para usar a GPU para inferência, verifique se o software a seguir está instalado no dispositivo:
+ OpenCL versão 1.0 ou posterior
+ Python 3.7 e pip
**nota**
Se o dispositivo for pré-construído com o Python 3.6, você poderá criar um symlink para o Python 3.7. Para obter mais informações, consulte [Step 2](#python-symlink).
+ [NumPy](https://pypi.org/project/numpy/)
+ [OpenCV sobre rodas](https://pypi.org/project/opencv-python/)
1. Faça download de imagens PNG ou JPG estáticas para a função do Lambda para usá-las na classificação de imagens. O exemplo funciona melhor com arquivos de imagem pequenos.
Salve os arquivos de imagem no diretório que contém o arquivo `greengrassObjectClassification.py` (ou em um subdiretório desse diretório). Isso está no pacote de implantação da função do Lambda do qual você fez upload em [Etapa 4: Crie e publique uma função do Lambda](#ml-console-create-lambda).
**nota**
Se estiver usando AWS DeepLens, você pode usar a câmera integrada ou montar sua própria câmera para realizar inferência em imagens capturadas em vez de imagens estáticas. No entanto, recomendamos que você comece com imagens estáticas primeiro.
Se utilizar uma câmara, verifique se o pacote APT `awscam` está instalado e atualizado. Para mais informações, consulte [Atualizar seu dispositivo AWS DeepLens](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html) no *Guia do desenvolvedor AWS DeepLens *.
1. Se você não estiver usando o Python 3.7, crie um symlink do Python 3.x para o Python 3.7. Isso configura seu dispositivo para usar o Python 3 com. AWS IoT Greengrass Execute o seguinte comando para localizar a instalação do Python:
```
which python3
```
Execute o comando a seguir para criar o symlink:
```
sudo ln -s path-to-python-3.x/python3.x path-to-python-3.7/python3.7
```
Reinicie o dispositivo.
1. Edite a configuração da função do Lambda. Siga o procedimento em [Etapa 5: adicionar a função do Lambda ao grupo do Greengrass](#ml-console-config-lambda).
**nota**
Recomendamos que você execute sua função do Lambda sem conteinerização, a menos que seu caso de negócios faça essa exigência. Isso ajuda a habilitar o acesso à GPU e à câmera do seu dispositivo sem configurar os recursos do dispositivo. Se você executa sem conteinerização, também deve conceder acesso root às suas funções do Lambda AWS IoT Greengrass .
1. **Para executar sem conteinerização:**
+ Para **Usuário e grupo do sistema**, selecione **Another user ID/group ID**. Para **ID de usuário do sistema**, insira **0**. Para **ID do grupo do sistema**, insira **0**.
Isso permite que sua função do Lambda seja executada como root. Para obter mais informações sobre como executar como raiz, consulte [Definir a identidade de acesso padrão para as funções do Lambda em um grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**dica**
Você também deve atualizar seu arquivo `config.json` para conceder acesso root à sua função do Lambda. Para o procedimento, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root).
+ Para **Conteinerização da função do Lambda**, selecione **Sem contêiner**.
Para obter mais informações sobre como executar sem conteinerização, consulte [Considerações ao escolher a conteinerização de função do Lambda](lambda-group-config.md#lambda-containerization-considerations).
+ Atualize o valor de **Tempo limite** para 5 segundos. Isso garante que a solicitação não expire muito cedo. Leva alguns minutos para que a inferência seja executada após a configuração.
+ Em **Fixado**, selecione **Verdadeiro**.
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys)**, selecione **Habilitado**.
+ Em **Lambda lifecycle (Ciclo de vida Lambda)**, selecione **Make this function long-lived and keep it running indefinitely (Definir esta função de longa duração e mantê-la em execução indefinidamente)**.
1. **Em vez disso, para executar no modo conteinerizado:**
**nota**
Não recomendamos a execução no modo conteinerizado, a menos que seu caso de negócios faça essa exigência.
+ Atualize o valor de **Tempo limite** para 5 segundos. Isso garante que a solicitação não expire muito cedo. Leva alguns minutos para que a inferência seja executada após a configuração.
+ Para **Fixado**, selecione **Verdadeiro**.
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
1. **Se estiver executando no modo conteinerizado**, adicione o recurso de dispositivo local necessário para conceder acesso à GPU do seu dispositivo.
**nota**
Se você executar no modo não conteinerizado, AWS IoT Greengrass poderá acessar a GPU do seu dispositivo sem configurar os recursos do dispositivo.
1. Na página de configuração do grupo, selecione a guia **Recursos**.
1. Selecione **Adicionar recurso local**.
1. Defina o recurso:
+ Em **Resource Name (Nome do recurso)**, insira **renderD128**.
+ Em **Tipo de recurso**, selecione **Dispositivo local**.
+ Em **Device path (Caminho do dispositivo)**, insira **/dev/dri/renderD128**.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
+ Para **Afiliações da função do Lambda**, conceda a permissão **Acesso para leitura e gravação** para sua função Lambda.
## Configurando um NVIDIA Jetson TX2
Para executar este tutorial em um NVIDIA Jetson TX2, forneça imagens de origem e configure a função Lambda. Se estiver usando a GPU, você também deverá adicionar recursos do dispositivo local.
1. Certifique-se de que seu dispositivo Jetson esteja configurado para que você possa instalar o software AWS IoT Greengrass Core. Para obter mais informações sobre como configurar seu projeto, consulte [Configurar outros dispositivos](setup-filter.other.md).
1. Abra a MXNet documentação, acesse [Instalando MXNet em um Jetson](https://mxnet.apache.org/get_started/jetson_setup) e siga as instruções para instalar MXNet no dispositivo Jetson.
**nota**
Se você quiser criar a MXNet partir do código-fonte, siga as instruções para criar a biblioteca compartilhada. Edite as seguintes configurações em seu `config.mk` arquivo para trabalhar com um TX2 dispositivo Jetson:
Adicione `-gencode arch=compute-62, code=sm_62` à `CUDA_ARCH` configuração.
Ligue o CUDA.
```
USE_CUDA = 1
```
1. Faça download de imagens PNG ou JPG estáticas para a função do Lambda para usá-las na classificação de imagens. O aplicativo funciona melhor com arquivos de imagem pequenos. Se preferir, é possível instrumentar uma câmera na placa Jetson para capturar as imagens de origem.
Salve seus arquivos de imagem no diretório que contém o arquivo `greengrassObjectClassification.py`. Você também pode salvá-los em um subdiretório desse diretório. Esse diretório está no pacote de implantação da função do Lambda do qual você fez upload em [Etapa 4: Crie e publique uma função do Lambda](#ml-console-create-lambda).
1. Crie um link simbólico do Python 3.7 para o Python 3.6 para usar o Python 3 com o. AWS IoT Greengrass Execute o seguinte comando para localizar a instalação do Python:
```
which python3
```
Execute o comando a seguir para criar o symlink:
```
sudo ln -s path-to-python-3.6/python3.6 path-to-python-3.7/python3.7
```
Reinicie o dispositivo.
1. Certifique-se de que a conta `ggc_user` do sistema possa usar a MXNet estrutura:
```
“sudo -u ggc_user bash -c 'python3 -c "import mxnet"'
```
1. Edite a configuração da função do Lambda. Siga o procedimento em [Etapa 5: adicionar a função do Lambda ao grupo do Greengrass](#ml-console-config-lambda).
**nota**
Recomendamos que você execute sua função do Lambda sem conteinerização, a menos que seu caso de negócios faça essa exigência. Isso ajuda a habilitar o acesso à GPU e à câmera do seu dispositivo sem configurar os recursos do dispositivo. Se você executa sem conteinerização, também deve conceder acesso root às suas funções do Lambda AWS IoT Greengrass .
1. **Para executar sem conteinerização:**
+ Para **Usuário e grupo do sistema**, selecione **Another user ID/group ID**. Para **ID de usuário do sistema**, insira **0**. Para **ID do grupo do sistema**, insira **0**.
Isso permite que sua função do Lambda seja executada como root. Para obter mais informações sobre como executar como raiz, consulte [Definir a identidade de acesso padrão para as funções do Lambda em um grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**dica**
Você também deve atualizar seu arquivo `config.json` para conceder acesso root à sua função do Lambda. Para o procedimento, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root).
+ Para **conteinerização da função do Lambda**, selecione **Sem contêiner**.
Para obter mais informações sobre como executar sem conteinerização, consulte [Considerações ao escolher a conteinerização de função do Lambda](lambda-group-config.md#lambda-containerization-considerations).
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
+ Em **Variáveis de ambiente**, adicione os seguintes pares chave-valor à sua função do Lambda. Isso configura AWS IoT Greengrass para usar a MXNet estrutura.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/ml-console.html)
1. **Em vez disso, para executar no modo conteinerizado:**
**nota**
Não recomendamos a execução no modo conteinerizado, a menos que seu caso de negócios faça essa exigência.
+ Aumente o valor de **Memory limit (Limite de memória)**. Use 500 MB para a CPU ou pelo menos 2000 MB para a GPU.
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
+ Em **Variáveis de ambiente**, adicione os seguintes pares chave-valor à sua função do Lambda. Isso configura AWS IoT Greengrass para usar a MXNet estrutura.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/ml-console.html)
1. **Se estiver executando no modo conteinerizado**, adicione os recursos de dispositivo local a seguir para conceder acesso à GPU do seu dispositivo. Siga o procedimento em [Etapa 6: Adicionar recursos ao grupo do Greengrass](#ml-console-add-resources).
**nota**
Se você executar no modo não conteinerizado, AWS IoT Greengrass poderá acessar a GPU do seu dispositivo sem configurar os recursos do dispositivo.
Para cada recurso:
+ Em **Resource type**, selecione **Device**.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/ml-console.html)
1. **Se estiver executando no modo conteinerizado**, adicione o recurso de volume local a seguir para conceder acesso à câmera do seu dispositivo. Siga o procedimento em [Etapa 6: Adicionar recursos ao grupo do Greengrass](#ml-console-add-resources).
**nota**
Se você executar no modo não conteinerizado, AWS IoT Greengrass poderá acessar a câmera do seu dispositivo sem configurar os recursos de volume.
+ Em **Tipo de recurso**, selecione **Volume**.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/ml-console.html)
# Como configurar a inferência otimizada de aprendizado de máquina usando o Console de gerenciamento da AWS
Para seguir as etapas deste tutorial, você deve estar usando o AWS IoT Greengrass Core v1.10 ou posterior.
Você pode usar o compilador de aprendizado profundo SageMaker AI Neo para otimizar a eficiência de previsão de modelos de inferência de aprendizado de máquina nativos no Tensorflow, Apache MXNet PyTorch, ONNX e XGBoost estruturas para um espaço menor e um desempenho mais rápido. Em seguida, você pode baixar o modelo otimizado, instalar o tempo de execução de aprendizado profundo SageMaker AI Neo e implantá-lo em seus AWS IoT Greengrass dispositivos para uma inferência mais rápida.
Este tutorial descreve como usar o Console de gerenciamento da AWS para configurar um grupo do Greengrass para executar um exemplo de inferência Lambda que reconhece imagens de uma câmera localmente, sem enviar dados para a nuvem. O exemplo de inferência acessa o módulo da câmera em um Raspberry Pi. Neste tutorial, você faz download de um modelo predefinido que é treinado por Resnet-50 e otimizado no compilador de aprendizado profundo Neo. Em seguida, você usa o modelo para realizar a classificação local de imagens em seu AWS IoT Greengrass dispositivo.
O tutorial contém as seguintes etapas de nível elevado:
1. [Configurar o Raspberry Pi](#config-raspberry-pi-dlc)
1. [Instalar o tempo de execução de aprendizagem profunda do Neo](#install-dlr)
1. [Criar uma função do Lambda de inferência](#ml-console-dlc-create-lambda)
1. [Adicionar a função do Lambda ao grupo](#ml-console-dlc-config-lambda)
1. [Adicionar um recurso de modelo otimizado do Neo ao grupo](#ml-console-dlc-add-resources)
1. [Adicionar um recurso de dispositivo de câmera ao grupo](#ml-console-dlc-add-cam-resource)
1. [Adicionar assinaturas ao grupo](#ml-console-dlc-add-subscription)
1. [Implantar o grupo](#ml-console-dlc-deploy-group)
1. [Testar o exemplo](#ml-console-dlc-test-app)
## Pré-requisitos
Para concluir este tutorial, é necessário:
+ Raspberry Pi 4 Modelo B, ou Raspberry Pi 3 Modelo B/B\$1, instalado e configurado para uso com. AWS IoT Greengrass Para configurar seu Raspberry Pi com o AWS IoT Greengrass, execute o script [Greengrass Device Setup](quick-start.md) ou conclua o [Módulo 1](https://docs.aws.amazon.com/greengrass/latest/developerguide/module1.html) e o [Módulo 2](https://docs.aws.amazon.com/greengrass/latest/developerguide/module2.html) do [Começando com AWS IoT Greengrass](gg-gs.md).
**nota**
O Raspberry Pi pode exigir uma [fonte de alimentação](https://www.raspberrypi.org/documentation/hardware/raspberrypi/power/) de 2,5 A para executar as estruturas de aprendizado profundo que normalmente são usadas para classificação de imagens. Uma fonte de alimentação com uma classificação mais baixa pode fazer com que o dispositivo seja reinicializado.
+ [Módulo de câmera Raspberry Pi V2 - 8 megapixels, 1080 p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Para aprender a configurar a câmera, consulte [Conectar a câmera](https://www.raspberrypi.org/documentation/usage/camera/) na documentação do Raspberry Pi.
+ Um grupo do Greengrass e um núcleo do Greengrass. Para saber como criar um grupo ou núcleo do Greengrass, consulte [Começando com AWS IoT Greengrass](gg-gs.md).
**nota**
Este tutorial usa um Raspberry Pi, mas AWS IoT Greengrass oferece suporte a outras plataformas, como [Intel Atom](#atom-lambda-dlc-config) e [NVIDIA](#jetson-lambda-dlc-config) Jetson. TX2 Se estiver usando o exemplo do Intel Atom, talvez seja necessário instalar o Python 3.6 em vez do Python 3.7. Para obter informações sobre como configurar seu dispositivo para que você possa instalar o software AWS IoT Greengrass Core, consulte[Configurar outros dispositivos](setup-filter.other.md).
Para plataformas de terceiros que AWS IoT Greengrass não oferecem suporte, você deve executar sua função Lambda no modo não conteinerizado. Para executar no modo sem contêiner, você deve executar sua função do Lambda como root. Para obter mais informações, consulte [Considerações ao escolher a conteinerização de função do Lambda](lambda-group-config.md#lambda-containerization-considerations) e [Definir a identidade de acesso padrão para as funções do Lambda em um grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
## Etapa 1: Configurar o Raspberry Pi
Nesta etapa, instale as atualizações no sistema operacional Raspbian, instale o software do módulo da câmera e as dependências do Python e ative a interface da câmera.
Execute os seguintes comandos no seu terminal do Raspberry Pi.
1. Instale as atualizações no Raspbian.
```
sudo apt-get update
sudo apt-get dist-upgrade
```
1. Instale a interface do `picamera` para o módulo da câmera e outras bibliotecas do Python que são necessárias para este tutorial.
```
sudo apt-get install -y python3-dev python3-setuptools python3-pip python3-picamera
```
Valide a instalação:
+ Verifique se a instalação do Python 3.7 inclui o pip.
```
python3 -m pip
```
Se o pip não estiver instalado, faça download dele no [site do pip](https://pip.pypa.io/en/stable/installing/) e execute o seguinte comando.
```
python3 get-pip.py
```
+ Verifique se a versão do Python é 3.7 ou superior.
```
python3 --version
```
Se a saída listar uma versão anterior, execute o seguinte comando.
```
sudo apt-get install -y python3.7-dev
```
+ Verifique se o Setuptools e Picamera foram instalados com êxito.
```
sudo -u ggc_user bash -c 'python3 -c "import setuptools"'
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Se a saída não contiver erros, a validação será bem-sucedida.
**nota**
Se o Python executável instalado no dispositivo for o `python3.7`, use `python3.7` em vez de `python3` para os comandos neste tutorial. Verifique se a instalação do pip mapeia para a versão correta do `python3` ou `python3.7` para evitar erros de dependência.
1. Reinicie o Raspberry Pi.
```
sudo reboot
```
1. Abra a ferramenta de configuração do Raspberry Pi.
```
sudo raspi-config
```
1. Use as setas do teclado para abrir **Interfacing Options** e habilitar a interface da câmera. Se solicitado, permita que o dispositivo seja reinicializado.
1. Use o seguinte comando para testar a configuração da câmera.
```
raspistill -v -o test.jpg
```
Isso abre uma janela de visualização no Raspberry Pi, salva uma imagem chamada `test.jpg` no seu diretório atual e exibe informações sobre a câmera no terminal do Raspberry Pi.
## Etapa 2: instalar o tempo de execução de aprendizado profundo do Amazon SageMaker Neo
Nesta etapa, você baixa o Runtime de Aprendizado Profundo (DLR) e o instala no seu Raspberry Pi.
**nota**
Recomendamos instalar a versão 1.1.0 para este tutorial.
1. Inicie sessão no seu Raspberry Pi remotamente.
```
ssh pi@your-device-ip-address
```
1. Abra a documentação do DLR, abra [Installing DLR](https://neo-ai-dlr.readthedocs.io/en/latest/install.html) e localize o URL de roda para dispositivos Raspberry Pi. Depois, siga as instruções para instalar o DLR no dispositivo. Por exemplo, você pode usar o pip:
```
pip3 install rasp3b-wheel-url
```
1. Depois de instalar o DLR, valide a seguinte configuração:
+ Verifique se a conta do sistema do `ggc_user` pode usar a biblioteca do DLR.
```
sudo -u ggc_user bash -c 'python3 -c "import dlr"'
```
+ Verifique se NumPy está instalado.
```
sudo -u ggc_user bash -c 'python3 -c "import numpy"'
```
## Etapa 3: Criar uma função de inferência da função do Lambda
Nesta etapa, crie um pacote de implantação da função do Lambda e uma função do Lambda Depois, publique uma versão da função e crie um alias.
1. No computador, faça download do exemplo do DLR para Raspberry Pi em [Exemplos de machine learning](what-is-gg.md#gg-ml-samples).
1. Não descompacte o arquivo `dlr-py3-armv7l.tar.gz` obtido por download.
```
cd path-to-downloaded-sample
tar -xvzf dlr-py3-armv7l.tar.gz
```
O diretório `examples` no pacote de exemplo extraído contém o código e as dependências da função.
+ O `inference.py` é o código de inferência usado neste tutorial. Você pode usar esse código como modelo para criar sua própria função de inferência.
+ `greengrasssdk` é a versão 1.5.0 do SDK do AWS IoT Greengrass Core para Python.
**nota**
Se uma nova versão estiver disponível, você poderá fazer download dela e atualizar a versão do SDK no seu pacote de implantação. Para obter mais informações, consulte [AWS IoT Greengrass Core SDK para GitHub Python on](https://github.com/aws/aws-greengrass-core-sdk-python/).
1. Compacte o conteúdo do diretório `examples` em um arquivo chamado `optimizedImageClassification.zip`. Esse é o pacote de implantação.
```
cd path-to-downloaded-sample/dlr-py3-armv7l/examples
zip -r optimizedImageClassification.zip .
```
O pacote de implantação contém seu código e as dependências da função. Isso inclui o código que invoca o Python do Neo deep learning runtime APIs para realizar inferência com os modelos do compilador de aprendizado profundo Neo.
**nota**
Verifique se os arquivos `.py` e as dependências estão na raiz do diretório.
1. Agora, adicione a função do Lambda ao seu grupo do Greengrass.
Na página do console do Lambda, selecione **Funções** e, em seguida, **Criar função**.
1. Selecione **Criar do zero** e use os valores a seguir para criar a função:
+ Em **Function name** (Nome da função), insira **optimizedImageClassification**.
+ Em **Runtime (Tempo de execução)**, selecione **Python 3.7**.
Em **Permissões**, mantenha a configuração padrão. Isso cria uma função de execução que concede permissões básicas do Lambda. Essa função não é usada por AWS IoT Greengrass.
![\[A seção Informações básicas da página de criação de função.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/ml-dlc-inference/gg-dlr-lambda-creation.png)
1. Selecione **Criar função**.
Agora, carregue o seu pacote de implantação da função do Lambda e registre o manipulador.
1. Na guia **Código**, em **Fonte do código**, selecione **Fazer upload a partir de**. No menu suspenso, selecione o **arquivo .zip**.
![\[O menu suspenso Fazer upload a partir de com o arquivo .zip destacado.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/lra-console/upload-deployment-package.png)
1. Selecione seu pacote de implantação `optimizedImageClassification.zip` e, em seguida, selecione **Salvar**.
1. Na guia **Código** da função, em **Configurações de runtime**, selecione **Editar** e insira os valores a seguir.
+ Em **Runtime (Tempo de execução)**, selecione **Python 3.7**.
+ Em **Handler (Manipulador)**, insira **inference.handler**.
Selecione **Salvar**.
![\[A seção Configurações de runtime com Upload destacado.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-lambda-upload.png)
Em seguida, publique a primeira versão da sua função do Lambda. Em seguida, crie um [alias para a versão](https://docs.aws.amazon.com/lambda/latest/dg/versioning-aliases.html).
**nota**
Os grupos do Greengrass podem fazer referência a uma função do Lambda por alias (recomendado) ou por versão. Usar um alias facilita o gerenciamento de atualizações de código porque você não precisa alterar a tabela de assinaturas nem a definição do grupo ao atualizar a função do código. Em vez disso, você pode simplesmente apontar o alias para a nova versão da função.
1. No menu **Actions**, selecione **Publish new version**.
![\[A opção Publish new version (Publicar nova versão) no menu Actions (Ações).\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-publish-new.png)
1. Em **Version description (Descrição da versão)**, insira **First version** e, em seguida, selecione **Publish (Publicar)**.
1. Na página de configuração **optimizedImageClassification: 1**, no menu **Ações**, escolha **Criar alias**.
![\[A opção Create alias (Criar alias) no menu Actions (Ações).\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/ml-dlc-inference/gg-ml2-create-alias.png)
1. Na página **Create a new alias**, use os seguintes valores:
+ Em **Nome**, digite **mlTestOpt**.
+ Em **Version (Versão)**, insira **1**.
**nota**
AWS IoT Greengrass **não oferece suporte a aliases Lambda para as versões \$1LATEST.**
1. Escolha **Criar**.
Agora, adicione a função do Lambda ao seu grupo do Greengrass.
## Etapa 4: adicionar a função do Lambda ao grupo do Greengrass
Nesta etapa, adicione a função do Lambda ao grupo e configura seu ciclo de vida.
Primeiro, adicione a função do Lambda ao seu grupo do Greengrass.
1. No painel de navegação do AWS IoT console, em **Gerenciar**, expanda dispositivos **Greengrass** e **escolha Grupos (**V1).
1. Na página de configuração do grupo, selecione a guia **funções do Lambda** e, em seguida selecione **Adicionar**.
1. Escolha a **função Lambda** e selecione. **optimizedImageClassification**
1. Na **versão da função do Lambda**, selecione o alias para a versão que você publicou.
Em seguida, configure o ciclo de vida da função do Lambda.
1. Na seção **configuração da função do Lambda**, faça as atualizações a seguir.
**nota**
Recomendamos que você execute sua função do Lambda sem conteinerização, a menos que seu caso de negócios faça essa exigência. Isso ajuda a habilitar o acesso à GPU e à câmera do seu dispositivo sem configurar os recursos do dispositivo. Se você executa sem conteinerização, também deve conceder acesso root às suas funções do Lambda AWS IoT Greengrass .
1. **Para executar sem conteinerização:**
+ Para **Usuário e grupo do sistema**, selecione **Another user ID/group ID**. Para **ID de usuário do sistema**, insira **0**. Para **ID do grupo do sistema**, insira **0**.
Isso permite que sua função do Lambda seja executada como root. Para obter mais informações sobre como executar como raiz, consulte [Definir a identidade de acesso padrão para as funções do Lambda em um grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**dica**
Você também deve atualizar seu arquivo `config.json` para conceder acesso root à sua função do Lambda. Para o procedimento, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root).
+ Para **conteinerização da função do Lambda**, selecione **Sem contêiner**.
Para obter mais informações sobre como executar sem conteinerização, consulte [Considerações ao escolher a conteinerização de função do Lambda](lambda-group-config.md#lambda-containerization-considerations).
+ Em **Timeout (Tempo limite)**, insira **10 seconds**.
+ Para **Fixado**, selecione **Verdadeiro**.
Para obter mais informações, consulte [Configuração do ciclo de vida das funções do Lambda do Greengrass](lambda-functions.md#lambda-lifecycle).
+ Em **Parâmetro adicional**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
1. **Em vez disso, para executar no modo conteinerizado:**
**nota**
Não recomendamos a execução no modo conteinerizado, a menos que seu caso de negócios faça essa exigência.
+ Para **Usuário e grupo do sistema**, selecione **Usar padrão de grupo**.
+ Para **Conteinerização da função do Lambda**, selecione **Usar padrão de grupo**.
+ Em **Memory limit (Limite de memória)**, insira **1024 MB**.
+ Em **Timeout (Tempo limite)**, insira **10 seconds**.
+ Para **Fixado**, selecione **Verdadeiro**.
Para obter mais informações, consulte [Configuração do ciclo de vida das funções do Lambda do Greengrass](lambda-functions.md#lambda-lifecycle).
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
1. Selecione **Adicionar função do Lambda**.
## Etapa 5: Adicionar um recurso de modelo otimizado para SageMaker IA NEO ao grupo Greengrass
Nesta etapa, crie um recurso para o modelo de inferência de ML otimizado e o carrega em um bucket do Amazon S3. Em seguida, localize o modelo carregado do Amazon S3 no AWS IoT Greengrass console e associe o recurso recém-criado à função Lambda. Isso possibilita que a função acesse os recursos no dispositivo básico.
1. No computador, navegue até o diretório `resnet50` no pacote de exemplo que você descompactou em [Etapa 3: Criar uma função de inferência da função do Lambda](#ml-console-dlc-create-lambda).
**nota**
Se estiver usando o exemplo do NVIDIA Jetson, precisará usar o diretório `resnet18` no pacote de exemplo. Para obter mais informações, consulte [Configurando um NVIDIA Jetson TX2](#jetson-lambda-dlc-config).
```
cd path-to-downloaded-sample/dlr-py3-armv7l/models/resnet50
```
Esse diretório contém artefatos de modelo pré-compilados para um modelo de classificação de imagem treinado com Resnet-50.
1. Compacte os arquivos dentro do diretório `resnet50` em um arquivo chamado `resnet50.zip`.
```
zip -r resnet50.zip .
```
1. Na página de configuração de grupo AWS IoT Greengrass do seu grupo, escolha a guia **Recursos**. Navegue até a seção **Machine Learning** e, em seguida selecione **Adicionar recurso de machine learning**. Na página **Create a machine learning resource (Criar recurso de Machine Learning)**, em **Resource name (Nome do recurso)**, insira **resnet50\$1model**.
1. Em **Fonte do modelo**, selecione **Usar um modelo armazenado no S3, como um modelo otimizado por meio do compilador de aprendizado profundo**.
1. Em **URI do S3**, selecione **Procurar no S3**.
**nota**
Atualmente, os modelos otimizados de SageMaker IA são armazenados automaticamente no Amazon S3. Você pode localizar seu modelo otimizado no bucket de seu Amazon S3 usando essa opção. Para obter mais informações sobre otimização de modelos em SageMaker IA, consulte a [documentação do SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).
1. Selecione **Upload a model (Fazer upload de um modelo)**.
1. Na guia do console do Amazon S3, carregue o arquivo zip em um bucket do Amazon S3. Para obter informações, consulte [Como carregar arquivos e pastas em um bucket do S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html) no *Guia do usuário do Amazon Simple Storage Service*.
**nota**
O nome do bucket deve conter a string **greengrass**. Selecione um nome exclusivo (como **greengrass-dlr-bucket-*user-id*-*epoch-time***). Não use ponto (`.`) no nome do bucket.
1. Na guia do AWS IoT Greengrass console, localize e escolha seu bucket do Amazon S3. Localize o arquivo `resnet50.zip` carregado e, em seguida selecione **Select (Selecionar)**. Talvez seja necessário atualizar a página para atualizar a lista de buckets e arquivos disponíveis.
1. Em **Caminho de destino**, insira **/ml\$1model**.
![\[O caminho de destino atualizado.\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/images/ml-dlc-inference/local-path.png)
Este é o destino do modelo local no namespace de runtime do Lambda. Quando você implanta o grupo, AWS IoT Greengrass recupera o pacote do modelo de origem e, em seguida, extrai o conteúdo para o diretório especificado.
**nota**
Recomendamos que você use o caminho exato fornecido para o seu caminho local. O uso de um caminho de destino do modelo local diferente nesta etapa causa imprecisão em alguns comandos de solução de problemas fornecidos neste tutorial. Se você usar um caminho diferente, deverá configurar uma variável de ambiente `MODEL_PATH` que use o caminho exato fornecido aqui. Para obter informações sobre as variáveis de ambiente, consulte [Variáveis de ambiente do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html).
1. **Se estiver executando no modo conteinerizado:**
1. Em **Proprietário do grupo do sistema e permissões de acesso ao arquivo**, selecione **Especificar grupos e permissões do sistema**.
1. Selecione **Acesso somente leitura** e, em seguida, **Adicionar recurso**.
## Etapa 6: Adicionar um recurso de dispositivo de câmera a um grupo do Greengrass
Nesta etapa, crie um recurso para o módulo da câmera e afilie-o com a função do Lambda. Isso possibilita que a função do Lambda acesse o recurso no dispositivo básico.
**nota**
Se você executar no modo não conteinerizado, AWS IoT Greengrass poderá acessar a GPU e a câmera do dispositivo sem configurar esse recurso do dispositivo.
1. Na página de configuração do grupo, selecione **Recursos**.
1. Na guia **Recursos locais**, selecione **Adicionar recurso local**.
1. Na página **Adicionar recurso local**, use os seguintes valores:
+ Em **Resource Name (Nome do recurso)**, insira **videoCoreSharedMemory**.
+ Em **Resource type**, selecione **Device**.
+ Em **Caminho do dispositivo local**, insira **/dev/vcsm**.
O caminho do dispositivo é o caminho absoluto local do recurso do dispositivo. Este caminho só pode se referir a um dispositivo de caractere ou dispositivo de blocos em `/dev`.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
A opção **Group owner file access permission** permite conceder permissões adicionais de acesso a arquivos para o processo do Lambda. Para obter mais informações, consulte [Permissão de acesso a arquivo do proprietário do grupo](access-local-resources.md#lra-group-owner).
1. Na parte inferior da página, selecione **Adicionar recurso**.
1. Na guia **Recursos**, crie outro recurso local escolhendo **Adicionar** e use os seguintes valores:
+ Em **Resource Name (Nome do recurso)**, insira **videoCoreInterface**.
+ Em **Resource type**, selecione **Device**.
+ Em **Caminho do dispositivo local**, insira **/dev/vchiq**.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
1. Selecione **Adicionar recurso**.
## Etapa 7: Adicionar assinaturas ao grupo do Greengrass
Nesta etapa, adicione assinaturas ao grupo. Essas assinaturas permitem que a função Lambda envie resultados de previsão AWS IoT publicando em um tópico do MQTT.
1. Na página de configuração do grupo, selecione a guia **Assinaturas** e, em seguida, **Adicionar assinatura**.
1. Na página **Criar uma assinatura**, configure a origem e o destino, da seguinte forma:
1. Em **Tipo de fonte**, escolha **Função Lambda** e, em seguida, escolha. **optimizedImageClassification**
1. Em **Tipo de destino**, selecione **Serviço** e então **IoT Cloud**.
1. Em **Filtro de tópicos**, insira **/resnet-50/predictions** e, em seguida, selecione **Criar assinatura**.
1. Adicione uma segunda assinatura. Selecione a guia **Assinaturas**, selecione **Adicionar assinatura** e configure a origem e o destino, da seguinte forma:
1. Em **Tipo de origem**, selecione **Serviços** e em seguida **IoT Cloud**.
1. Em **Tipo de destino**, escolha **Função Lambda** e, em seguida, escolha. **optimizedImageClassification**
1. Em **Filtro de tópicos**, insira **/resnet-50/test** e, em seguida, selecione **Criar assinatura**.
## Etapa 8: Implantar o grupo do Greengrass
Nesta etapa, implante a versão atual da definição do grupo ao dispositivo de núcleo do Greengrass. A definição contém a função do Lambda, recursos e configurações de inscrição que você adicionou.
1. Certifique-se de que o AWS IoT Greengrass núcleo esteja funcionando. Execute os seguintes comandos no seu terminal do Raspberry Pi, conforme necessário.
1. Para verificar se o daemon está em execução:
```
ps aux | grep -E 'greengrass.*daemon'
```
Se a saída contém uma entrada `root` para `/greengrass/ggc/packages/latest-core-version/bin/daemon`, o daemon está em execução.
1. Para iniciar o daemon:
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
1. Na página de configuração do grupo, selecione **Implantar**.
1. Na guia **Funções do Lambda**, selecione **Detector de IP** e selecione **Editar**.
1. Na caixa de diálogo **Editar configurações do detector de IP**, selecione **Detectar e substituir automaticamente os endpoints de atendente MQTT** e selecione **Salvar**.
Isso permite que os dispositivos adquiram automaticamente as informações de conectividade para o núcleo, como endereço IP, DNS e o número da porta. A detecção automática é recomendada, mas AWS IoT Greengrass também oferece suporte a endpoints especificados manualmente. Você só é solicitado pelo método de descoberta na primeira vez em que o grupo for implantado.
**nota**
Se solicitado, conceda permissão para criar a função de [serviço do Greengrass](service-role.md) e associá-la à Conta da AWS sua na atual. Região da AWS Essa função permite AWS IoT Greengrass acessar seus recursos em AWS serviços.
A página **Deployments** mostra a data e hora, ID de versão e status da implantação. Quando concluída, o status exibido para a implantação deve ser **Concluída**.
Para obter mais informações sobre implantações, consulte [Implante AWS IoT Greengrass grupos em um AWS IoT Greengrass núcleo](deployments.md). Para obter ajuda sobre a solução de problemas, consulte [Solução de problemas AWS IoT Greengrass](gg-troubleshooting.md).
## Testar o exemplo de inferência
Agora você pode verificar se a implementação foi configurada corretamente. Para testar, inscreva-se no tópico `/resnet-50/predictions` e publique qualquer mensagem no tópico `/resnet-50/test`. Isso aciona a função do Lambda para tirar uma foto com seu Raspberry Pi e executar inferência na imagem capturada.
**nota**
Se estiver usando o exemplo do NVIDIA Jetson, use os tópicos `resnet-18/predictions` e `resnet-18/test`.
**nota**
Se um monitor estiver conectado ao Raspberry Pi, o feed da câmera ao vivo será exibido em uma janela de visualização.
1. Na página inicial do AWS IoT console, em **Teste**, escolha **Cliente de teste MQTT**.
1. Em **Assinaturas**, selecione **Inscrever-se em um tópico**. Use os seguintes valores. Deixe as opções restantes em seus valores padrão.
+ Em **Subscription topic (Tópico de assinatura)**, insira **/resnet-50/predictions**.
+ Em **Configuração adicional**, para **exibição da carga útil do MQTT**, selecione **Exibir cargas úteis como strings**.
1. Selecione **Subscribe**.
1. Selecione **Publicar em um tópico**, insira **/resnet-50/test** como o **Nome do tópico** e selecione **Publicar**.
1. Se o teste for bem-sucedido, a mensagem publicada faz com que a câmera do Raspberry Pi capture uma imagem. Uma mensagem da função do Lambda é exibida na parte inferior da página. A mensagem contém o resultado de previsão da imagem, usando o formato: nome da classe prevista, probabilidade e pico de utilização da memória.
## Como configurar um Intel Atom
Para executar este tutorial em um dispositivo Intel Atom, você deve fornecer imagens de origem, configurar a função do Lambda e adicionar outro recurso de dispositivo local. Para usar a GPU para inferência, verifique se o software a seguir está instalado no dispositivo:
+ OpenCL versão 1.0 ou posterior
+ Python 3.7 e pip
+ [NumPy](https://pypi.org/project/numpy/)
+ [OpenCV sobre rodas](https://pypi.org/project/opencv-python/)
1. Faça download de imagens PNG ou JPG estáticas para a função do Lambda para usá-las na classificação de imagens. O exemplo funciona melhor com arquivos de imagem pequenos.
Salve os arquivos de imagem no diretório que contém o arquivo `inference.py` (ou em um subdiretório desse diretório). Isso está no pacote de implantação da função do Lambda do qual você fez upload em [Etapa 3: Criar uma função de inferência da função do Lambda](#ml-console-dlc-create-lambda).
**nota**
Se estiver usando AWS DeepLens, você pode usar a câmera integrada ou montar sua própria câmera para realizar inferência em imagens capturadas em vez de imagens estáticas. No entanto, recomendamos que você comece com imagens estáticas primeiro.
Se utilizar uma câmara, verifique se o pacote APT `awscam` está instalado e atualizado. Para mais informações, consulte [Atualizar seu AWS DeepLens dispositivo](https://docs.aws.amazon.com/deeplens/latest/dg/deeplens-manual-updates.html) no *AWS DeepLens Guia do desenvolvedor*.
1. Edite a configuração da função do Lambda. Siga o procedimento em [Etapa 4: adicionar a função do Lambda ao grupo do Greengrass](#ml-console-dlc-config-lambda).
**nota**
Recomendamos que você execute sua função do Lambda sem conteinerização, a menos que seu caso de negócios faça essa exigência. Isso ajuda a habilitar o acesso à GPU e à câmera do seu dispositivo sem configurar os recursos do dispositivo. Se você executa sem conteinerização, também deve conceder acesso root às suas funções do Lambda AWS IoT Greengrass .
1. **Para executar sem conteinerização:**
+ Para **Usuário e grupo do sistema**, selecione **Another user ID/group ID**. Para **ID de usuário do sistema**, insira **0**. Para **ID do grupo do sistema**, insira **0**.
Isso permite que sua função do Lambda seja executada como root. Para obter mais informações sobre como executar como raiz, consulte [Definir a identidade de acesso padrão para as funções do Lambda em um grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**dica**
Você também deve atualizar seu arquivo `config.json` para conceder acesso root à sua função do Lambda. Para o procedimento, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root).
+ Para **conteinerização da função do Lambda**, selecione **Sem contêiner**.
Para obter mais informações sobre como executar sem conteinerização, consulte [Considerações ao escolher a conteinerização de função do Lambda](lambda-group-config.md#lambda-containerization-considerations).
+ Aumente o valor de **Timeout (Tempo limite)** para 2 minutos. Isso garante que a solicitação não expire muito cedo. Leva alguns minutos para que a inferência seja executada após a configuração.
+ Para **Fixado**, selecione **Verdadeiro**.
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
1. **Em vez disso, para executar no modo conteinerizado:**
**nota**
Não recomendamos a execução no modo conteinerizado, a menos que seu caso de negócios faça essa exigência.
+ Aumente o valor de **Memory limit (Limite de memória)** para 3000 MB.
+ Aumente o valor de **Timeout (Tempo limite)** para 2 minutos. Isso garante que a solicitação não expire muito cedo. Leva alguns minutos para que a inferência seja executada após a configuração.
+ Para **Fixado**, selecione **Verdadeiro**.
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
1. Adicione seu recurso de modelo otimizado do Neo ao grupo Carregue os recursos do modelo no diretório `resnet50` do pacote de amostra que você descompactou em [Etapa 3: Criar uma função de inferência da função do Lambda](#ml-console-dlc-create-lambda). Esse diretório contém artefatos de modelo pré-compilados para um modelo de classificação de imagem treinado com Resnet-50. Use o procedimento em [Etapa 5: Adicionar um recurso de modelo otimizado para SageMaker IA NEO ao grupo Greengrass](#ml-console-dlc-add-resources) com as seguintes atualizações.
+ Compacte os arquivos dentro do diretório `resnet50` em um arquivo chamado `resnet50.zip`.
+ Na página **Create a machine learning resource (Criar recurso de Machine Learning)**, em **Resource name (Nome do recurso)**, insira **resnet50\$1model**.
+ Carregue o arquivo `resnet50.zip`.
1. **Se estiver executando no modo conteinerizado**, adicione o recurso de dispositivo local necessário para conceder acesso à GPU do seu dispositivo.
**nota**
Se você executar no modo não conteinerizado, AWS IoT Greengrass poderá acessar a GPU do seu dispositivo sem configurar os recursos do dispositivo.
1. Na página de configuração do grupo, selecione a guia **Recursos**.
1. Na seção **Recursos locais**, selecione **Adicionar recurso local**.
1. Defina o recurso:
+ Em **Resource Name (Nome do recurso)**, insira **renderD128**.
+ Em **Resource type**, selecione **Device**.
+ Em **Caminho do dispositivo local**, insira **/dev/dri/renderD128**.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
## Configurando um NVIDIA Jetson TX2
Para executar este tutorial em um NVIDIA Jetson TX2, forneça imagens de origem, configure a função Lambda e adicione mais recursos do dispositivo local.
1. Certifique-se de que seu dispositivo Jetson esteja configurado para que você possa instalar o software AWS IoT Greengrass Core e usar a GPU para inferência. Para obter mais informações sobre como configurar seu projeto, consulte [Configurar outros dispositivos](setup-filter.other.md). Para usar a GPU para inferência em um NVIDIA Jetson TX2, você deve instalar o CUDA 10.0 e o cuDNN 7.0 em seu dispositivo ao criar imagens de sua placa com o Jetpack 4.3.
1. Faça download de imagens PNG ou JPG estáticas para a função do Lambda para usá-las na classificação de imagens. O exemplo funciona melhor com arquivos de imagem pequenos.
Salve seus arquivos de imagem no diretório que contém o arquivo `inference.py`. Você também pode salvá-los em um subdiretório desse diretório. Esse diretório está no pacote de implantação da função do Lambda do qual você fez upload em [Etapa 3: Criar uma função de inferência da função do Lambda](#ml-console-dlc-create-lambda).
**nota**
Em vez disso, você pode optar por instrumentar uma câmera na placa Jetson para capturar as imagens de origem. No entanto, recomendamos que você comece com imagens estáticas primeiro.
1. Edite a configuração da função do Lambda. Siga o procedimento em [Etapa 4: adicionar a função do Lambda ao grupo do Greengrass](#ml-console-dlc-config-lambda).
**nota**
Recomendamos que você execute sua função do Lambda sem conteinerização, a menos que seu caso de negócios faça essa exigência. Isso ajuda a habilitar o acesso à GPU e à câmera do seu dispositivo sem configurar os recursos do dispositivo. Se você executa sem conteinerização, também deve conceder acesso root às suas funções do Lambda AWS IoT Greengrass .
1. **Para executar sem conteinerização:**
+ Para **Executar como**, selecione **Another user ID/group ID**. Em **UID**, insira **0**. Para **GUID**, insira **0**.
Isso permite que sua função do Lambda seja executada como root. Para obter mais informações sobre como executar como raiz, consulte [Definir a identidade de acesso padrão para as funções do Lambda em um grupo](lambda-group-config.md#lambda-access-identity-groupsettings).
**dica**
Você também deve atualizar seu arquivo `config.json` para conceder acesso root à sua função do Lambda. Para o procedimento, consulte [Executar uma função do Lambda como raiz](lambda-group-config.md#lambda-running-as-root).
+ Para **conteinerização da função do Lambda**, selecione **Sem contêiner**.
Para obter mais informações sobre como executar sem conteinerização, consulte [Considerações ao escolher a conteinerização de função do Lambda](lambda-group-config.md#lambda-containerization-considerations).
+ Aumente o valor de **Timeout (Tempo limite)** para 5 minutos. Isso garante que a solicitação não expire muito cedo. Leva alguns minutos para que a inferência seja executada após a configuração.
+ Para **Fixado**, selecione **Verdadeiro**.
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
1. **Em vez disso, para executar no modo conteinerizado:**
**nota**
Não recomendamos a execução no modo conteinerizado, a menos que seu caso de negócios faça essa exigência.
+ Aumente o valor de **Memory limit (Limite de memória)**. Para usar o modelo fornecido no modo de GPU, use 2000 MB.
+ Aumente o valor de **Timeout (Tempo limite)** para 5 minutos. Isso garante que a solicitação não expire muito cedo. Leva alguns minutos para que a inferência seja executada após a configuração.
+ Para **Fixado**, selecione **Verdadeiro**.
+ Em **Parâmetros adicionais**, para **Acesso de leitura ao diretório /sys**, selecione **Habilitado**.
1. Adicione seu recurso de modelo otimizado do Neo ao grupo Carregue os recursos do modelo no diretório `resnet18` do pacote de amostra que você descompactou em [Etapa 3: Criar uma função de inferência da função do Lambda](#ml-console-dlc-create-lambda). Esse diretório contém artefatos de modelo pré-compilados para um modelo de classificação de imagem treinado com Resnet-18. Use o procedimento em [Etapa 5: Adicionar um recurso de modelo otimizado para SageMaker IA NEO ao grupo Greengrass](#ml-console-dlc-add-resources) com as seguintes atualizações.
+ Compacte os arquivos dentro do diretório `resnet18` em um arquivo chamado `resnet18.zip`.
+ Na página **Create a machine learning resource (Criar recurso de Machine Learning)**, em **Resource name (Nome do recurso)**, insira **resnet18\$1model**.
+ Carregue o arquivo `resnet18.zip`.
1. **Se estiver executando no modo conteinerizado**, adicione os recursos de dispositivo local necessários para conceder acesso à GPU do seu dispositivo.
**nota**
Se você executar no modo não conteinerizado, AWS IoT Greengrass poderá acessar a GPU do seu dispositivo sem configurar os recursos do dispositivo.
1. Na página de configuração do grupo, selecione a guia **Recursos**.
1. Na seção **Recursos locais**, selecione **Adicionar recurso local**.
1. Defina cada recurso:
+ Em **Resource name (Nome do recurso)** e **Device path (Caminho do dispositivo)**, use os valores na tabela a seguir. Crie um recurso de dispositivo para cada linha na tabela.
+ Em **Resource type**, selecione **Device**.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/ml-dlc-console.html)
1. **Se estiver executando no modo conteinerizado**, adicione o recurso de volume local a seguir para conceder acesso à câmera do seu dispositivo. Siga o procedimento em [Etapa 5: Adicionar um recurso de modelo otimizado para SageMaker IA NEO ao grupo Greengrass](#ml-console-dlc-add-resources).
**nota**
Se você executar no modo não conteinerizado, AWS IoT Greengrass poderá acessar a câmera do dispositivo sem configurar os recursos do dispositivo.
+ Em **Tipo de recurso**, selecione **Volume**.
+ Em **Permissões do proprietário do grupo do sistema e de acesso a arquivos**, selecione **Adicionar automaticamente permissões de sistema de arquivos do grupo do sistema que é proprietário do recurso**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/greengrass/v1/developerguide/ml-dlc-console.html)
1. Atualize suas assinaturas de grupo para usar o diretório correto. Use o procedimento em [Etapa 7: Adicionar assinaturas ao grupo do Greengrass](#ml-console-dlc-add-subscription) com as seguintes atualizações.
+ Para o primeiro filtro de tópico, digite **/resnet-18/predictions**.
+ Para o segundo filtro de tópico, digite **/resnet-18/test**.
1. Atualize suas assinaturas de teste para usar o diretório correto. Use o procedimento em [Testar o exemplo de inferência](#ml-console-dlc-test-app) com as seguintes atualizações.
+ Em **Assinaturas**, selecione **Inscrever-se em um tópico**. Em **Subscription topic (Tópico de assinatura)**, insira **/resnet-18/predictions**.
+ Na página `/resnet-18/predictions`, especifique o tópico `/resnet-18/test` no qual publicar.
## Solução de problemas de inferência AWS IoT Greengrass de ML
Se o teste não for bem-sucedido, você poderá tentar as etapas de solução de problemas a seguir. Execute os comandos no seu terminal Raspberry Pi.
### Verificar logs de erros
1. Alterne para o usuário raiz e navegue até o diretório `log`. O acesso aos AWS IoT Greengrass registros requer permissões de root.
```
sudo su
cd /greengrass/ggc/var/log
```
1. Verifique `runtime.log` em busca de algum erro.
```
cat system/runtime.log | grep 'ERROR'
```
Você também pode verificar em seu log se há erros na sua função do Lambda definida pelo usuário:
```
cat user/your-region/your-account-id/lambda-function-name.log | grep 'ERROR'
```
Para obter mais informações, consulte [Solução de problemas com logs](gg-troubleshooting.md#troubleshooting-logs).
### Verifique se a função do Lambda foi implantada com êxito
1. Liste o conteúdo do Lambda implementado no diretório `/lambda`. Substitua os valores de espaço reservado antes de executar o comando.
```
cd /greengrass/ggc/deployment/lambda/arn:aws:lambda:region:account:function:function-name:function-version
ls -la
```
1. Verifique se o diretório contém o mesmo conteúdo do pacote de implantação `optimizedImageClassification.zip` que você carregou no [Etapa 3: Criar uma função de inferência da função do Lambda](#ml-console-dlc-create-lambda).
Verifique se os arquivos `.py` e as dependências estão na raiz do diretório.
### Verifique se o modelo de inferência foi implantado com sucesso
1. Encontre o número de identificação de processo (PID) do runtime do Lambda:
```
ps aux | grep lambda-function-name
```
Na saída, o PID aparece na segunda coluna da linha para o processo de runtime do Lambda.
1. Digite o namespace de runtime do Lambda. Certifique-se de substituir o *pid* valor do espaço reservado antes de executar o comando.
**nota**
Este diretório e seu conteúdo estão no namespace de runtime do Lambda para que não sejam visíveis em um namespace comum do Linux.
```
sudo nsenter -t pid -m /bin/bash
```
1. Liste o conteúdo do diretório local que você especificou para o recurso de ML.
**nota**
Se o caminho do recurso de ML for diferente de `ml_model`, você deverá substituí-lo aqui.
```
cd /ml_model
ls -ls
```
Você deve ver os arquivos a seguir:
```
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
```
### A função Lambda não consegue encontrar `/dev/dri/renderD128`
Isso poderá ocorrer se o OpenCL não puder se conectar aos dispositivos de GPU de que precisa. Você deve criar recursos de dispositivo para os dispositivos necessários para a função do lambda.
## Próximas etapas
Em seguida, explore outros modelos otimizados. Para obter informações, consulte a [documentação do SageMaker AI Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html).