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á.
# Tutorial: Execute inferência de classificação de imagens de amostra em imagens de uma câmera usando o TensorFlow Lite
Este tutorial mostra como usar o componente de inferência de [classificação de imagem TensorFlow Lite](tensorflow-lite-image-classification-component.md) para realizar exemplos de inferência de classificação de imagens em imagens de uma câmera localmente em um dispositivo principal do Greengrass. Esse componente inclui as seguintes dependências de componentes:
+ TensorFlow Componente de armazenamento de modelos de classificação de imagem Lite
+ TensorFlow Componente Lite Runtime
**nota**
Este tutorial acessa o módulo de câmera para dispositivos [Raspberry Pi](https://www.raspberrypi.org/) ou [NVIDIA Jetson Nano](https://developer.nvidia.com/embedded/jetson-nano), mas AWS IoT Greengrass oferece suporte a outros dispositivos nas plataformas ARMv7l, Armv8 ou x86\$164. Para configurar uma câmera para um dispositivo diferente, consulte a documentação relevante do seu dispositivo.
Para obter mais informações sobre machine learning nos dispositivos Greengrass, consulte [Executar a inferência de machine learning](perform-machine-learning-inference.md).
**Topics**
+ [Pré-requisitos](#ml-tutorial-camera-prereqs)
+ [Etapa 1: configurar o módulo da câmera no seu dispositivo](#ml-tutorial-image-classification-camera-install)
+ [Etapa 2: verificar a assinatura do tópico de notificações padrão](#ml-image-classification-camera-subscribe)
+ [Etapa 3: modificar a configuração do componente de classificação de imagem TensorFlow Lite e implantá-la](#ml-image-classification-camera-deploy)
+ [Etapa 4: visualizar resultados de inferência](#ml-image-classification-camera-results)
+ [Próximas etapas](#ml-image-classification-camera-next-steps)
## Pré-requisitos
Para concluir este tutorial, primeiro é necessário concluir a [Tutorial: Execute inferência de classificação de imagens de amostra usando o Lite TensorFlow](ml-tutorial-image-classification.md).
Você precisará dos seguintes itens:
+ Um dispositivo central Linux Greengrass com uma interface de câmera. Este tutorial acessa o módulo da câmera em um dos seguintes dispositivos compatíveis:
+ [Raspberry Pi](https://www.raspberrypi.org/) executando o [Raspberry Pi OS](https://www.raspberrypi.org/downloads/) (anteriormente chamado de Raspbian)
+ [NVIDIA Jetson Nano](https://developer.nvidia.com/embedded/jetson-nano)
Para obter informações sobre como configurar um dispositivo principal do Greengrass, consulte [Tutorial: Conceitos básicos do AWS IoT Greengrass V2](getting-started.md).
O dispositivo principal deve atender aos seguintes requisitos:
+ Nos dispositivos principais do Greengrass que executam o Amazon Linux 2 ou o Ubuntu 18.04, a [Biblioteca do GNU C](https://www.gnu.org/software/libc/) (glibc) versão 2.27 ou posterior está instalada no dispositivo.
+ Em dispositivos Armv7l, como o Raspberry Pi, as dependências do OpenCV-Python estão instaladas no dispositivo. Execute o seguinte comando para instalar as dependências.
```
sudo apt-get install libopenjp2-7 libilmbase23 libopenexr-dev libavcodec-dev libavformat-dev libswscale-dev libv4l-dev libgtk-3-0 libwebp-dev
```
+ Os dispositivos Raspberry Pi que executam o Raspberry Pi OS Bullseye devem atender aos seguintes requisitos:
+ NumPy 1.22.4 ou posterior instalado no dispositivo. O Raspberry Pi OS Bullseye inclui uma versão anterior do NumPy, então você pode executar o seguinte comando para atualizar NumPy o dispositivo.
```
pip3 install --upgrade numpy
```
+ A pilha de câmeras antiga habilitada no dispositivo. O Raspberry Pi OS Bullseye inclui uma nova pilha de câmeras que está habilitada por padrão e não é compatível, portanto você precisa habilitar a pilha de câmeras antiga.
**Para habilitar a pilha de câmeras antiga**
1. Execute o comando abaixo para abrir a ferramenta de configuração do Raspberry Pi.
```
sudo raspi-config
```
1. Selecione **Opções de interface**.
1. Selecione **Câmera antiga** para habilitar a pilha de câmeras antiga.
1. Reinicie o Raspberry Pi.
+ Para dispositivos Raspberry Pi ou NVIDIA Jetson Nano, [módulo de câmera Raspberry Pi V2 - 8 megapixels, 1080p](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.
## Etapa 1: configurar o módulo da câmera no seu dispositivo
Nesta etapa, você instala e ativa o módulo da câmera para o seu dispositivo. Execute os seguintes comandos no dispositivo.
------
#### [ Raspberry Pi (Armv7l) ]
1. Instale a `picamera` interface do módulo da câmera. Execute o seguinte comando para instalar o módulo da câmera e as outras bibliotecas Python necessárias para este tutorial.
```
sudo apt-get install -y python3-picamera
```
1. Verifique se o Picamera foi instalado com sucesso.
```
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 arquivo 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 dispositivo.
```
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. Execute 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.
1. Execute o comando a seguir para criar um link simbólico para permitir que o componente de inferência acesse sua câmera a partir do ambiente virtual criado pelo componente de runtime.
```
sudo ln -s /usr/lib/python3/dist-packages/picamera "MLRootPath/greengrass_ml_tflite_venv/lib/python3.7/site-packages"
```
O valor padrão *MLRootPath* para este tutorial é`/greengrass/v2/work/variant.TensorFlowLite/greengrass_ml`. A pasta `greengrass_ml_tflite_venv` nesse local é criada quando você implanta o componente de inferência pela primeira vez em [Tutorial: Execute inferência de classificação de imagens de amostra usando o Lite TensorFlow](ml-tutorial-image-classification.md).
------
#### [ Jetson Nano (Armv8) ]
1. Execute o seguinte comando para testar a configuração da câmera.
```
gst-launch-1.0 nvarguscamerasrc num-buffers=1 ! "video/x-raw(memory:NVMM), width=1920, height=1080, format=NV12, framerate=30/1" ! nvjpegenc ! filesink location=test.jpg
```
Isso captura e salva uma imagem chamada `test.jpg` em seu diretório atual.
1. (Opcional) Reinicie o dispositivo. Se você encontrar problemas ao executar o comando `gst-launch` na etapa anterior, a reinicialização do dispositivo poderá resolver esses problemas.
```
sudo reboot
```
**nota**
Para dispositivos Armv8 (AArch64), como o Jetson Nano, você não precisa criar um link simbólico para permitir que o componente de inferência acesse a câmera a partir do ambiente virtual criado pelo componente de tempo de execução.
------
## Etapa 2: verificar a assinatura do tópico de notificações padrão
Em[Tutorial: Execute inferência de classificação de imagens de amostra usando o Lite TensorFlow](ml-tutorial-image-classification.md), você configurou que o cliente AWS IoT MQTT está configurado no AWS IoT console para assistir às mensagens MQTT publicadas pelo componente de classificação de imagem TensorFlow Lite sobre o `ml/tflite/image-classification` tópico. No AWS IoT console, verifique se essa assinatura existe. Caso contrário, siga as etapas [Etapa 1: assinar o tópico de notificações padrão](ml-tutorial-image-classification.md#ml-image-classification-subscribe) para assinar este tópico antes de implantar o componente em seu dispositivo principal do Greengrass.
## Etapa 3: modificar a configuração do componente de classificação de imagem TensorFlow Lite e implantá-la
Nesta etapa, você configura e implanta o componente de classificação de imagem TensorFlow Lite em seu dispositivo principal:
### Para configurar e implantar o componente de classificação de imagem TensorFlow Lite (console)
1. No menu de navegação do [console do AWS IoT Greengrass](https://console.aws.amazon.com/greengrass), selecione **Componentes**.
1. Na página **Componentes**, na guia **Componentes públicos**, escolha `aws.greengrass.TensorFlowLiteImageClassification`.
1. Na página **aws.greengrass.TensorFlowLiteImageClassification**, escolha **Implantar**.
1. Em **Adicionar à implantação**, escolha uma das seguintes opções:
1. Para mesclar esse componente a uma implantação existente em seu dispositivo de destino, escolha **Adicionar à implantação existente** e selecione a implantação que você deseja revisar.
1. Para criar uma nova implantação em seu dispositivo de destino, escolha **Criar nova implantação**. Se você tiver uma implantação existente em seu dispositivo, escolher essa etapa substituirá a implantação existente.
1. Na página **Especificar destino**, faça o seguinte:
1. Em **Informações de implantação**, insira ou modifique o nome amigável para sua implantação.
1. Em **Destinos de implantação**, selecione um alvo para sua implantação e escolha **Avançar**. Você não pode alterar o destino de implantação se estiver revisando uma implantação existente.
1. Na página **Selecionar componentes**, em **Componentes públicos**, verifique se o componente `aws.greengrass.TensorFlowLiteImageClassification` está selecionado e escolha **Avançar**.
1. Na página **Configurar componentes**, faça o seguinte:
1. Selecione o componente de inferência e escolha **Configurar componente**.
1. Em **Atualização de configuração**, insira a atualização de configuração a seguir na caixa **Configuração a ser mesclada**.
```
{
"InferenceInterval": "60",
"UseCamera": "true"
}
```
Com essa atualização de configuração, o componente acessa o módulo da câmera em seu dispositivo e realiza inferências nas imagens tiradas pela câmera. O código de inferência é executado a cada 60 segundos.
1. Escolha **Confirmar** e, em seguida, **Avançar**.
1. Na página **Definir configurações avançadas**, mantenha as configurações padrão e escolha **Avançar**.
1. Na página **Revisar**, escolha **Implantar**.
### Para configurar e implantar o componente de classificação de imagem TensorFlow Lite (AWS CLI)
1. Crie um `deployment.json` arquivo para definir a configuração de implantação do componente de classificação de imagem TensorFlow Lite. Esse arquivo deve ser semelhante ao seguinte:
```
{
"targetArn":"targetArn",
"components": {
"aws.greengrass.TensorFlowLiteImageClassification": {
"componentVersion": 2.1.0,
"configurationUpdate": {
"InferenceInterval": "60",
"UseCamera": "true"
}
}
}
}
```
+ No campo `targetArn`, substitua `targetArn` pelo nome do recurso da Amazon (ARN) da coisa ou do grupo de coisas do destino da implantação, no formato a seguir:
+ Coisa: `arn:aws:iot:region:account-id:thing/thingName`
+ Grupo de coisas: `arn:aws:iot:region:account-id:thinggroup/thingGroupName`
+ Este tutorial usa o componente versão 2.1.0. No objeto `aws.greengrass.TensorFlowLiteImageClassification` componente, *2.1.0* substitua para usar uma versão diferente do componente de classificação de imagem TensorFlow Lite.
Com essa atualização de configuração, o componente acessa o módulo da câmera em seu dispositivo e realiza inferências nas imagens tiradas pela câmera. O código de inferência é executado a cada 60 segundos. Substitua os valores a seguir:
1. Execute o comando a seguir para implantar o componente de classificação de imagem TensorFlow Lite no dispositivo:
```
aws greengrassv2 create-deployment \
--cli-input-json file://path/to/deployment.json
```
A implantação pode levar vários minutos para ser concluída. Na próxima etapa, verifique o log do componente para verificar se a implantação foi concluída com êxito e para ver os resultados da inferência.
## Etapa 4: visualizar resultados de inferência
Depois de implantar o componente, você pode visualizar os resultados da inferência no registro do componente em seu dispositivo principal do Greengrass e no cliente MQTT AWS IoT no console. AWS IoT Para assinar o tópico no qual o componente publica resultados de inferência, consulte [Etapa 2: verificar a assinatura do tópico de notificações padrão](#ml-image-classification-camera-subscribe).
**Topics**
+ **AWS IoT Cliente MQTT** — Para visualizar os resultados que o componente de inferência publica no [tópico de notificações padrão](ml-tutorial-image-classification.md#ml-image-classification-subscribe), conclua as seguintes etapas:
1. No menu de navegação do [console do AWS IoT](https://console.aws.amazon.com/iot/), escolha **Teste, Cliente de teste MQTT**.
1. Em **Assinaturas**, escolha **ml/tflite/image-classification**.
+ **Log do componente**: para visualizar os resultados da inferência no registro do componente, execute o comando a seguir em seu dispositivo principal do Greengrass.
```
sudo tail -f /greengrass/v2/logs/aws.greengrass.TensorFlowLiteImageClassification.log
```
Se você não conseguir ver os resultados da inferência no log do componente ou no cliente MQTT, a implantação falhou ou não atingiu o dispositivo principal. Isso pode ocorrer se seu dispositivo principal não estiver conectado à Internet ou não tiver as permissões necessárias para executar o componente. Execute o comando a seguir em seu dispositivo principal para visualizar o arquivo de log do software AWS IoT Greengrass principal. Esse arquivo inclui logs do serviço de implantação do dispositivo principal do Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
Para obter mais informações, consulte [Solução de problemas de inferência de Machine learning do](ml-troubleshooting.md).
## Próximas etapas
Este tutorial mostra como usar o componente de classificação de imagem TensorFlow Lite, com opções de configuração personalizadas para realizar a classificação de imagens de amostra em imagens tiradas por uma câmera.
Para obter mais informações sobre como personalizar a configuração de componentes públicos ou criar componentes personalizados de machine learning, consulte [Personalizar seus componentes de machine learning](ml-customization.md).