Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial: Lakukan inferensi klasifikasi gambar sampel pada gambar dari kamera menggunakan TensorFlow Lite
Tutorial ini menunjukkan cara menggunakan komponen inferensi [klasifikasi gambar TensorFlow Lite](tensorflow-lite-image-classification-component.md) untuk melakukan inferensi klasifikasi gambar sampel pada gambar dari kamera secara lokal pada perangkat inti Greengrass. Komponen ini mencakup dependensi komponen berikut:
+ TensorFlow Komponen penyimpanan model klasifikasi gambar Lite
+ TensorFlow Komponen runtime Lite
**catatan**
Tutorial ini mengakses modul kamera untuk perangkat [Raspberry Pi](https://www.raspberrypi.org/) atau [NVIDIA Jetson Nano](https://developer.nvidia.com/embedded/jetson-nano), tetapi AWS IoT Greengrass mendukung perangkat lain pada platform ARMv7L, Armv8, atau x86\$164. Untuk menyiapkan kamera untuk perangkat lain, lihat dokumentasi yang relevan untuk perangkat Anda.
Untuk informasi selengkapnya tentang pembelajaran mesin di perangkat Greengrass, lihat. [Lakukan inferensi machine learning](perform-machine-learning-inference.md)
**Topics**
+ [Prasyarat](#ml-tutorial-camera-prereqs)
+ [Langkah 1: Konfigurasikan modul kamera pada perangkat Anda](#ml-tutorial-image-classification-camera-install)
+ [Langkah 2: Verifikasi langganan Anda ke topik notifikasi default](#ml-image-classification-camera-subscribe)
+ [Langkah 3: Ubah konfigurasi komponen klasifikasi gambar TensorFlow Lite dan terapkan](#ml-image-classification-camera-deploy)
+ [Langkah 4: Lihat hasil inferensi](#ml-image-classification-camera-results)
+ [Langkah selanjutnya](#ml-image-classification-camera-next-steps)
## Prasyarat
Untuk menyelesaikan tutorial ini, Anda harus terlebih dahulu menyelesaikan [Tutorial: Lakukan inferensi klasifikasi gambar sampel menggunakan Lite TensorFlow](ml-tutorial-image-classification.md).
Anda juga memerlukan hal berikut:
+ Perangkat inti Greengrass Linux dengan antarmuka kamera. Tutorial ini mengakses modul kamera pada satu perangkat yang didukung berikut:
+ [Raspberry V](https://www.raspberrypi.org/) yang menjalankan [Raspberry Pi OS](https://www.raspberrypi.org/downloads/) (sebelumnya disebut Raspbian)
+ [NVIDIA Jetson Nano](https://developer.nvidia.com/embedded/jetson-nano)
Untuk informasi lebih lanjut tentang cara menyiapkan perangkat inti Greengrass, lihat [Tutorial: Memulai dengan AWS IoT Greengrass V2](getting-started.md).
Perangkat inti harus memenuhi persyaratan berikut:
+ Pada perangkat inti Greengrass yang menjalankan Amazon Linux 2 atau Ubuntu 18.04, [Pustaka GNU C](https://www.gnu.org/software/libc/) (glibc) versi 2.27 atau yang lebih baru diinstal pada perangkat tersebut.
+ Pada perangkat ARMv7L, seperti Raspberry Pi, dependensi untuk OpenCV-Python diinstal pada perangkat. Jalankan perintah berikut untuk menginstal dependensi.
```
sudo apt-get install libopenjp2-7 libilmbase23 libopenexr-dev libavcodec-dev libavformat-dev libswscale-dev libv4l-dev libgtk-3-0 libwebp-dev
```
+ Perangkat Raspberry Pi yang menjalankan Raspberry Pi OS Bullseye harus memenuhi persyaratan berikut:
+ NumPy 1.22.4 atau yang lebih baru diinstal pada perangkat. Raspberry Pi OS Bullseye menyertakan versi sebelumnya NumPy, sehingga Anda dapat menjalankan perintah berikut untuk meningkatkan NumPy pada perangkat.
```
pip3 install --upgrade numpy
```
+ Tumpukan kamera lama diaktifkan di perangkat. Raspberry Pi OS Bullseye menyertakan tumpukan kamera baru yang diaktifkan secara default dan tidak kompatibel, jadi Anda harus mengaktifkan tumpukan kamera lama.
**Untuk mengaktifkan tumpukan kamera lama**
1. Jalankan perintah berikut untuk membuka alat konfigurasi Raspberry Pi.
```
sudo raspi-config
```
1. Pilih **Opsi Antarmuka**.
1. Pilih **Kamera lama** untuk mengaktifkan tumpukan kamera lama.
1. Reboot Raspberry Pi.
+ Untuk perangkat Raspberry Pi atau NVIDIA Jetson Nano, [Modul Kamera Raspberry Pi V2 - 8 megapiksel, 1080p](https://www.amazon.com/Raspberry-Pi-Camera-Module-Megapixel/dp/B01ER2SKFS). Untuk mempelajari cara mengatur kamera, lihat [Menghubungkan kamera](https://www.raspberrypi.org/documentation/usage/camera/) dalam dokumentasi Raspberry Pi.
## Langkah 1: Konfigurasikan modul kamera pada perangkat Anda
Pada langkah ini, Anda menginstal dan mengaktifkan modul kamera untuk perangkat Anda. Jalankan perintah berikut pada perangkat.
------
#### [ Raspberry Pi (Armv7l) ]
1. Instal antarmuka `picamera` untuk modul kamera. Jalankan perintah berikut untuk menginstal modul kamera dan pustaka Python lain yang diperlukan untuk tutorial ini.
```
sudo apt-get install -y python3-picamera
```
1. Verifikasi bahwa Picamera berhasil diinstal.
```
sudo -u ggc_user bash -c 'python3 -c "import picamera"'
```
Jika output tidak mengandung kesalahan, validasi berhasil.
**catatan**
Jika file executable Python yang diinstal pada perangkat Anda adalah `python3.7`, gunakan `python3.7` alih-alih `python3` untuk perintah di tutorial ini. Pastikan bahwa instalasi pip Anda memetakan versi `python3.7` atau `python3` untuk menghindari kesalahan dependensi.
1. Reboot perangkat.
```
sudo reboot
```
1. Buka alat konfigurasi Raspberry Pi.
```
sudo raspi-config
```
1. Gunakan tombol panah untuk membuka **Opsi Antarmuka** dan mengaktifkan antarmuka kamera. Jika diminta, izinkan perangkat melakukan reboot.
1. Jalankan perintah berikut untuk menguji pengaturan kamera.
```
raspistill -v -o test.jpg
```
Hal ini akan membuka jendela pratinjau pada Raspberry Pi, menyimpan gambar bernama `test.jpg` pada direktori Anda saat ini, dan menampilkan informasi tentang kamera di terminal Raspberry Pi.
1. Jalankan perintah berikut untuk membuat symlink untuk mengaktifkan komponen inferensi untuk mengakses kamera Anda dari lingkungan virtual yang dibuat oleh komponen waktu aktif.
```
sudo ln -s /usr/lib/python3/dist-packages/picamera "MLRootPath/greengrass_ml_tflite_venv/lib/python3.7/site-packages"
```
Nilai default *MLRootPath* untuk tutorial ini adalah`/greengrass/v2/work/variant.TensorFlowLite/greengrass_ml`. Folder `greengrass_ml_tflite_venv` di lokasi ini dibuat ketika Anda men-deploy komponen inferensi untuk pertama kalinya di [Tutorial: Lakukan inferensi klasifikasi gambar sampel menggunakan Lite TensorFlow](ml-tutorial-image-classification.md).
------
#### [ Jetson Nano (Armv8) ]
1. Jalankan perintah berikut untuk menguji pengaturan kamera.
```
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
```
Hal ini akan menangkap dan menyimpan gambar bernama `test.jpg` pada direktori Anda saat ini.
1. (Opsional) Reboot perangkat. Jika Anda mengalami masalah saat menjalankan `gst-launch` pada langkah sebelumnya, dengan me-reboot perangkat, Anda dapat mengatasi masalah tersebut.
```
sudo reboot
```
**catatan**
Untuk perangkat Armv8 (AArch64), seperti Jetson Nano, Anda tidak perlu membuat symlink untuk mengaktifkan komponen inferensi untuk mengakses kamera dari lingkungan virtual yang dibuat oleh komponen runtime.
------
## Langkah 2: Verifikasi langganan Anda ke topik notifikasi default
Di[Tutorial: Lakukan inferensi klasifikasi gambar sampel menggunakan Lite TensorFlow](ml-tutorial-image-classification.md), Anda mengonfigurasi klien AWS IoT MQTT dikonfigurasi di AWS IoT konsol untuk menonton pesan MQTT yang diterbitkan oleh komponen klasifikasi gambar TensorFlow Lite pada topik tersebut. `ml/tflite/image-classification` Di AWS IoT konsol, verifikasi bahwa langganan ini ada. Jika tidak, ikuti langkah-langkah di [Langkah 1: Berlanggananlah topik notifikasi default](ml-tutorial-image-classification.md#ml-image-classification-subscribe) untuk berlangganan topik ini sebelum Anda men-deploy komponen ke perangkat inti Greengrass Anda.
## Langkah 3: Ubah konfigurasi komponen klasifikasi gambar TensorFlow Lite dan terapkan
Pada langkah ini, Anda mengonfigurasi dan menerapkan komponen klasifikasi gambar TensorFlow Lite ke perangkat inti Anda:
### Untuk mengonfigurasi dan menerapkan komponen klasifikasi gambar TensorFlow Lite (konsol)
1. Pada menu navigasi [konsol AWS IoT Greengrass](https://console.aws.amazon.com/greengrass) tersebut, pilih **Komponen**.
1. Pada halaman **Komponen**, pada tab **Komponen publik**, pilih `aws.greengrass.TensorFlowLiteImageClassification`.
1. Pada halaman **aws.greengrass.TensorFlowLiteImageClassification** pilih **Deploy**.
1. Dari **Tambahkan ke deployment**, pilih salah satu langkah berikut ini:
1. Untuk menggabungkan komponen ini ke deployment yang ada pada perangkat target Anda, pilih **Tambahkan ke deployment yang ada**, lalu pilih deployment yang ingin Anda revisi.
1. Untuk membuat deployment baru di perangkat target Anda, pilih **Buat deployment baru**. Jika Anda memiliki deployment yang ada di perangkat, dengan memilih langkah ini Anda akan menggantikan deployment yang ada.
1. Di halaman **Tentukan target**, lakukan hal berikut:
1. Di bawah informasi **Deployment**, masukkan atau ubah nama yang ramah untuk deployment Anda.
1. Di bawah **Target deployment**, pilih target untuk deployment Anda, dan pilih **Selanjutnya**. Anda tidak dapat mengubah target deployment jika Anda merevisi deployment yang ada.
1. Pada halaman **Pilih komponen**, di bawah **Komponen publik**, verifikasi bahwa komponen `aws.greengrass.TensorFlowLiteImageClassification` dipilih, dan pilih **Selanjutnya**.
1. Pada halaman **Konfigurasikan komponen**, lakukan hal berikut:
1. Pilih komponen inferensi, dan pilih **Konfigurasikan komponen**.
1. Di bawah **Pembaruan konfigurasi**, masukkan pembaruan konfigurasi berikut di kotak **Konfigurasi yang akan digabungkan**.
```
{
"InferenceInterval": "60",
"UseCamera": "true"
}
```
Dengan pembaruan konfigurasi ini, komponen akan mengakses modul kamera pada perangkat Anda dan melakukan inferensi pada gambar yang diambil oleh kamera. Kode inferensi berjalan setiap 60 detik.
1. Pilih **Konfirmasi** dan kemudian pilih **Selanjutnya**.
1. Pada halaman **Konfigurasikan pengaturan lanjutan**, simpan pengaturan konfigurasi default tersebut, dan pilih **Selanjutnya**.
1. Di halaman **Tinjauan**, pilih **Deploy**.
### Untuk mengonfigurasi dan menerapkan komponen klasifikasi gambar TensorFlow Lite ()AWS CLI
1. Buat `deployment.json` file untuk menentukan konfigurasi penerapan untuk komponen klasifikasi gambar TensorFlow Lite. File ini akan terlihat seperti berikut:
```
{
"targetArn":"targetArn",
"components": {
"aws.greengrass.TensorFlowLiteImageClassification": {
"componentVersion": 2.1.0,
"configurationUpdate": {
"InferenceInterval": "60",
"UseCamera": "true"
}
}
}
}
```
+ Di kolom `targetArn`, ganti `targetArn` dengan Amazon Resource Name (ARN) dari grup objek atau objek yang ditargetkan untuk deployment tersebut, dalam format berikut:
+ Objek: `arn:aws:iot:region:account-id:thing/thingName`
+ Grup objek: `arn:aws:iot:region:account-id:thinggroup/thingGroupName`
+ Tutorial ini menggunakan komponen versi 2.1.0. Dalam objek `aws.greengrass.TensorFlowLiteImageClassification` komponen, ganti *2.1.0* untuk menggunakan versi lain dari komponen klasifikasi gambar TensorFlow Lite.
Dengan pembaruan konfigurasi ini, komponen akan mengakses modul kamera pada perangkat Anda dan melakukan inferensi pada gambar yang diambil oleh kamera. Kode inferensi berjalan setiap 60 detik. Ganti nilai berikut
1. Jalankan perintah berikut untuk menerapkan komponen klasifikasi gambar TensorFlow Lite pada perangkat:
```
aws greengrassv2 create-deployment \
--cli-input-json file://path/to/deployment.json
```
Deployment ini dapat memakan waktu beberapa menit hingga selesai. Pada langkah berikutnya, periksa log komponen untuk memverifikasi bahwa deployment tersebut berhasil diselesaikan dan untuk melihat hasil inferensi.
## Langkah 4: Lihat hasil inferensi
Setelah menerapkan komponen, Anda dapat melihat hasil inferensi di log komponen di perangkat inti Greengrass Anda dan di klien MQTT di konsol. AWS IoT AWS IoT Untuk berlangganan topik di mana komponen menerbitkan hasil inferensi, lihat [Langkah 2: Verifikasi langganan Anda ke topik notifikasi default](#ml-image-classification-camera-subscribe).
**Topics**
+ **AWS IoT Klien MQTT** —Untuk melihat hasil yang diterbitkan komponen inferensi pada [topik notifikasi default](ml-tutorial-image-classification.md#ml-image-classification-subscribe), selesaikan langkah-langkah berikut:
1. Di menu navigasi [konsol AWS IoT](https://console.aws.amazon.com/iot/) tersebut, pilih **Uji, klien uji MQTT**.
1. Di bawah **Langganan**, pilih **ml/tflite/image-classification**.
+ **Log komponen**—Untuk melihat hasil inferensi dalam log komponen, jalankan perintah berikut pada perangkat inti Greengrass Anda.
```
sudo tail -f /greengrass/v2/logs/aws.greengrass.TensorFlowLiteImageClassification.log
```
Jika Anda tidak dapat melihat hasil inferensi di log komponen atau di klien MQTT, deployment tersebut gagal atau tidak mencapai perangkat inti. Hal ini dapat terjadi jika perangkat inti Anda tidak tersambung ke internet atau tidak memiliki izin yang diperlukan untuk menjalankan komponen. Jalankan perintah berikut pada perangkat inti Anda untuk melihat file log perangkat lunak AWS IoT Greengrass inti. File ini mencakup log dari layanan deployment perangkat inti Greengrass.
```
sudo tail -f /greengrass/v2/logs/greengrass.log
```
Untuk informasi selengkapnya, lihat [Menyelesaikan masalah inferensi machine learning](ml-troubleshooting.md).
## Langkah selanjutnya
Tutorial ini menunjukkan cara menggunakan komponen klasifikasi gambar TensorFlow Lite, dengan opsi konfigurasi khusus untuk melakukan klasifikasi gambar sampel pada gambar yang diambil oleh kamera.
Untuk informasi lebih lanjut tentang menyesuaikan konfigurasi komponen publik atau membuat komponen machine learning kustom, lihat [Sesuaikan komponen machine learning Anda](ml-customization.md).