Halo, kembali lagi dengan Series Machine Learning di Android. Pada artikel sebelumnya, kita sudah membahas Macam Cara Implementasi Machine Learning/AI di Aplikasi Android. Pada blog kali ini, kita akan mempraktikkan secara langsung salah satu framework yang disebutkan, yakni TensorFlow Lite (TFLite).
TensorFlow Lite adalah versi ringan dan efisien dari framework Tensorflow yang sering digunakan Machine Learning Developer untuk mengembangkan dan men-deploy model. Ia didesain sedemikian rupa sehingga memungkinkan kita untuk menjalankan model pada perangkat dengan resource yang terbatas, seperti handphone dan embedded system.
💻 Mulai Belajar Pemrograman
Belajar pemrograman di Dicoding Academy dan mulai perjalanan Anda sebagai developer profesional.
Daftar SekarangBeberapa contoh aplikasi yang menggunakan TensorFlow Lite adalah Gmail, Google Assistant, Google Nest, dan Shazam. Tentu nama-nama yang tidak asing, bukan?
Untuk yang sudah terbiasa berkecimpung di dunia Android dan tak mau ketinggalan hype teknologi AI, kamu tentu tidak hanya ingin menjadi pemakai saja, kan? Kamu tentu mau tahu dong cara mengimplementasikan machine learning di Android.Â
Nah, pada tutorial ini, kita akan membuat aplikasi klasifikasi objek dengan menggunakan TFLite. Menariknya, kamu tidak perlu tahu pemahaman machine learning yang mendalam untuk mengikuti tutorial ini. Penasaran? Yuk, simak langkah-langkahnya dan buat aplikasi AI pertamamu!
Persiapan Project
Supaya kamu bisa fokus praktik tentang penerapan TFLite, kami sudah menyediakan starter project yang berisi fungsi dasar kamera dengan menggunakan CameraX, sebuah library dari Android Jetpack untuk menampilkan kamera di dalam aplikasi secara langsung dengan lebih mudah.Â
Sebenarnya ada banyak cara untuk mendapatkan gambar di dalam aplikasi, seperti memilih gambar dari galeri atau memanfaatkan kamera bawaan menggunakan Camera Intent. Namun, di sini kita menggunakan CameraX supaya bisa menganalisis gambar secara real-time. Selain itu, di dalam CameraX juga terdapat ImageAnalysis yang bisa kita integrasikan dengan TFLite.
Okay, sekarang silakan langsung unduh atau clone proyek awal berikut:
Silakan buka proyek tersebut dengan menggunakan Android Studio. Jika kita perhatikan, di dalamnya sudah ada beberapa penambahan kode seperti berikut.
- Dependensi library CameraX di dalam build.gradle.kts.
- PreviewView dari CameraX dan TextView pada activity_main.xml.
- Pendefinisian Camera permission di dalam AndroidManifest.xml.
- Proses request Camera permission, inisialisasi ProcessCameraProvider untuk menampilkan kamera, dan implementasi ViewBinding di dalam MainActivity.
Berikut adalah tampilan aplikasi dari starter project jika dijalankan.
Setelah memberikan akses kamera, aplikasi dapat menampilkan kamera secara langsung.
Persiapan Model TFLite
Jika kamu sudah memiliki TensorFlow Model, konversi terlebih dahulu menjadi TensorFlow Lite Model dengan ekstensi .tflite. Alhasil, ukurannya menjadi lebih kecil, lebih efisien, dan mendukung framework TensorFlow Lite.
Apabila tidak memiliki model sendiri, kamu bisa memanfaatkan TensorFlow Lite Model Maker untuk melakukan transfer learning. Transfer learning adalah pendekatan untuk menggunakan model yang telah dilatih sebelumnya dalam mengerjakan tugas tertentu. Ini digunakan sebagai titik awal untuk membuat model baru dengan tugas serupa.Â
Jika kamu tidak memiliki latar belakang machine learning sebelumnya, kamu juga bisa memanfaatkan TensorFlow Hub untuk mencari referensi model yang sudah paten. Nah, pada latihan ini kita akan menggunakan model berikut untuk melakukan deteksi objek.
Silakan unduh model tersebut dan import ke dalam Android Studio dengan cara klik kanan pada folder app dan pilih New → Other → TensorFlow Lite Model. Dari sini, Anda jadi tahu kan bahwa sebenarnya Android Studio sudah bersahabat baik, lo dengan TFLite. Buktinya sudah ada fiturnya langsung untuk import dalam Android Studio.
Kemudian, pilih file tadi yangsudah diunduh pada Model location dan beri centang pada semua opsi.
Klik Finish dan lihatlah sekarang file tersebut terdapat di folder app/ml. Kamu pun dapat membaca metadata dari file tersebut berkat library yang ditambahkan sebelumnya.
File ini nanti dapat diakses layaknya asset dengan adanya penambahan konfigurasi pada build.gradle.kts.
|
1 2 3 4 5 6 7 |
android {    ...    buildFeatures {        viewBinding = true        mlModelBinding = true    } } |
Oke, sekarang model sudah siap, saatnya menambahkan library utama dari TensorFlow Lite untuk pemrosesan machine learning. Karena klasifikasi objek termasuk dalam kategori task-vision, tambahkan dependensi berikut pada build.gradle.kts.
|
1 2 3 4 5 |
dependencies { Â Â Â ... Â Â Â implementation("org.tensorflow:tensorflow-lite-gpu:2.13.0") Â Â Â implementation("org.tensorflow:tensorflow-lite-task-vision:0.4.4") } |
Jangan lupa untuk melakukan Sync Now setiap kali menambahkan library baru pada konfigurasi Gradle untuk mengunduhnya.
Membuat Helper TFLite
Setelah semua persiapan usai, kita akan membuat kelas helper untuk memudahkan kita mengelompokkan fungsi yang digunakan untuk melakukan proses ML. Selain itu, kode menjadi lebih rapi dan bersih dengan pemisahan ini.
Pertama, buat dulu class baru dengan cara klik kanan pada nama package dan pilih new → Kotlin Class/File. Kemudian tambahkan parameter dan listener seperti berikut.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
class ImageClassifierHelper( var threshold: Float = 0.1f, var maxResults: Int = 3, var numThreads: Int = 4, val modelName: String = "mobilenet_v1_1.0_224_quantized_1_metadata_1.tflite", val context: Context, val imageClassifierListener: ClassifierListener? ) { private var imageClassifier: ImageClassifier? = null interface ClassifierListener { fun onError(error: String) fun onResults( results: List<Classifications>?, inferenceTime: Long ) } } |
Listener di sini berfungsi untuk memberi tahu class utama ketika proses yang dilakukan berhasil atau gagal. Apabila proses berhasil, fungsi onResults yang dipanggil. Namun jika proses gagal, fungsi onError yang dipanggil. Inilah yang disebut dengan callback.
Selanjutnya, buat fungsi baru bernama setupImageClassifier dan panggil di dalam init supaya fungsi ini terpanggil setiap kali kelas ini dibuat.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
init { setupImageClassifier() } fun setupImageClassifier() { val optionsBuilder = ImageClassifier.ImageClassifierOptions.builder() .setScoreThreshold(threshold) .setMaxResults(maxResults) val baseOptionsBuilder = BaseOptions.builder().setNumThreads(numThreads) optionsBuilder.setBaseOptions(baseOptionsBuilder.build()) try { imageClassifier = ImageClassifier.createFromFileAndOptions(context, modelName, optionsBuilder.build()) } catch (e: IllegalStateException) { imageClassifierListener?.onError( "Image classifier failed to initialize. See error logs for details" ) Log.e("ImageClassifierHelper", "TFLite failed to load model with error: " + e.message) } } |
Di sini kita menyiapkan beberapa konfigurasi pada TensorFlow Lite sebelum melakukan pemrosesan. Berikut adalah fungsi yang digunakan.
- setScoreThreshold: Menentukan batas minimal keakuratan dari hasil yang ditampilkan. 0.1 artinya 10%.
- setMaxResults: Menentukan batas maksimal jumlah hasil yang ditampilkan.Â
- setNumThreads: Menentukan jumlah thread yang digunakan untuk melakukan pemrosesan ML.
- createFromFileAndOptions: Membuat ImageClassifier berdasarkan asset file model dan option yang didefinisikan sebelumnya.
Catatan:
Sebenarnya juga ada fungsi baseOptionsBuilder.useGpu() jika kamu ingin menentukan jalannya pemrosesan dilakukan di GPU, alih-alih di CPU. Namun, kamu perlu menambahkan library tensorflow-lite-gpu.
Mari kita lanjutkan penulisan kodenya. Masih pada berkas ImageClassifierHelper, buat sebuah fungsi baru untuk melakukan pemrosesan klasifikasi seperti berikut.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
fun classify(image: ImageProxy) { if (imageClassifier == null) { setupImageClassifier() } val bitmapBuffer = Bitmap.createBitmap( image.width, image.height, Bitmap.Config.ARGB_8888 ) image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer) } image.close() var inferenceTime = SystemClock.uptimeMillis() val imageProcessor = ImageProcessor.Builder().build() val tensorImage = imageProcessor.process(TensorImage.fromBitmap(bitmapBuffer)) val imageProcessingOptions = ImageProcessingOptions.builder() .setOrientation(getOrientationFromRotation(image.imageInfo.rotationDegrees)) .build() val results = imageClassifier?.classify(tensorImage, imageProcessingOptions) inferenceTime = SystemClock.uptimeMillis() - inferenceTime imageClassifierListener?.onResults( results, inferenceTime ) } private fun getOrientationFromRotation(rotation: Int): ImageProcessingOptions.Orientation { return when (rotation) { Surface.ROTATION_270 -> ImageProcessingOptions.Orientation.BOTTOM_RIGHT Surface.ROTATION_180 -> ImageProcessingOptions.Orientation.RIGHT_BOTTOM Surface.ROTATION_90 -> ImageProcessingOptions.Orientation.TOP_LEFT else -> ImageProcessingOptions.Orientation.RIGHT_TOP } } |
Di awal, kita periksa dulu instance ImageClassifier masih null atau tidak. Jika tidak, kita lanjut mengubah image buffer menjadi Bitmap dengan fungsi createBitmap. Setelah itu, buat TensorImage dari Bitmap tadi menggunakan fungsi process.Â
Setelah itu, kita siapkan juga ImageProcessingOptions untuk mengatur orientasi gambar input sesuai dengan gambar yang ada pada model. Hal ini diperlukan supaya hasil yang diberikan akurat.Â
Sebagai catatan, karena fungsi yang disediakan adalah setOrientation, kita perlu membuat fungsi baru untuk mengonversi rotationDegress menjadi orientation seperti contoh di atas.
Setelah kedua objek tersebut siap, kamu dapat memanggil fungsi classify untuk memulai proses pengklasifikasian. Selain itu, kamu juga membuat variabel inferenceTime guna menghitung waktu yang dibutuhkan untuk melakukan pemrosesan.Â
Terakhir, kita menyimpan data yang dihasilkan melalui fungsi imageClassifierListener?.onResults.
Alhasil, keseluruhan kode pada ImageClassifierHelper menjadi seperti berikut.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
class ImageClassifierHelper( var threshold: Float = 0.1f, var maxResults: Int = 3, var numThreads: Int = 4, val modelName: String = "mobilenet_v1_1.0_224_quantized_1_metadata_1.tflite", val context: Context, val imageClassifierListener: ClassifierListener? ) { private var imageClassifier: ImageClassifier? = null init { setupImageClassifier() } fun setupImageClassifier() { val optionsBuilder = ImageClassifier.ImageClassifierOptions.builder() .setScoreThreshold(threshold) .setMaxResults(maxResults) val baseOptionsBuilder = BaseOptions.builder().setNumThreads(numThreads) optionsBuilder.setBaseOptions(baseOptionsBuilder.build()) try { imageClassifier = ImageClassifier.createFromFileAndOptions(context, modelName, optionsBuilder.build()) } catch (e: IllegalStateException) { imageClassifierListener?.onError( "Image classifier failed to initialize. See error logs for details" ) Log.e("ImageClassifierHelper", "TFLite failed to load model with error: " + e.message) } } fun classify(image: ImageProxy) { if (imageClassifier == null) { setupImageClassifier() } val bitmapBuffer = Bitmap.createBitmap( image.width, image.height, Bitmap.Config.ARGB_8888 ) image.use { bitmapBuffer.copyPixelsFromBuffer(image.planes[0].buffer) } image.close() var inferenceTime = SystemClock.uptimeMillis() val imageProcessor = ImageProcessor.Builder().build() val tensorImage = imageProcessor.process(TensorImage.fromBitmap(bitmapBuffer)) val imageProcessingOptions = ImageProcessingOptions.builder() .setOrientation(getOrientationFromRotation(image.imageInfo.rotationDegrees)) .build() val results = imageClassifier?.classify(tensorImage, imageProcessingOptions) inferenceTime = SystemClock.uptimeMillis() - inferenceTime imageClassifierListener?.onResults( results, inferenceTime ) } private fun getOrientationFromRotation(rotation: Int): ImageProcessingOptions.Orientation { return when (rotation) { Surface.ROTATION_270 -> ImageProcessingOptions.Orientation.BOTTOM_RIGHT Surface.ROTATION_180 -> ImageProcessingOptions.Orientation.RIGHT_BOTTOM Surface.ROTATION_90 -> ImageProcessingOptions.Orientation.TOP_LEFT else -> ImageProcessingOptions.Orientation.RIGHT_TOP } } interface ClassifierListener { fun onError(error: String) fun onResults( results: List<Classifications>?, inferenceTime: Long ) } } |
Integrasi CameraX dengan TFLite
Setelah kelas helper sudah siap, kita akan mengintegrasikan ImageClassifier dengan CameraX dengan memanfaatkan ImageAnalysis sebagai UseCase pada argument terakhir fungsi bindToLifecycle.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
class MainActivity : AppCompatActivity() { private lateinit var binding: ActivityMainBinding private lateinit var imageClassifierHelper: ImageClassifierHelper ... private fun startCamera() { imageClassifierHelper = ImageClassifierHelper( context = this, imageClassifierListener = object : ImageClassifierHelper.ClassifierListener { override fun onError(error: String) { runOnUiThread { Toast.makeText(this@MainActivity, error, Toast.LENGTH_SHORT).show() } } override fun onResults(results: List<Classifications>?, inferenceTime: Long) { runOnUiThread { results?.let { it -> if (it.isNotEmpty() && it[0].categories.isNotEmpty()) { println(it) val sortedCategories = it[0].categories.sortedByDescending { it?.score } val displayResult = sortedCategories.joinToString("\n") { "${it.label} " + NumberFormat.getPercentInstance().format(it.score).trim() } binding.tvResult.text = displayResult } } } } }) val cameraProviderFuture = ProcessCameraProvider.getInstance(this) cameraProviderFuture.addListener({ val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get() val preview = Preview.Builder() .setTargetAspectRatio(AspectRatio.RATIO_4_3) .build() .also { it.setSurfaceProvider(binding.viewFinder.surfaceProvider) } val imageAnalyzer = ImageAnalysis.Builder() .setTargetAspectRatio(AspectRatio.RATIO_4_3) .setTargetRotation(binding.viewFinder.display.rotation) .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST) .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_RGBA_8888) .build() .also { it.setAnalyzer(Executors.newSingleThreadExecutor()) { image -> imageClassifierHelper.classify(image) } } try { cameraProvider.unbindAll() cameraProvider.bindToLifecycle( this, CameraSelector.DEFAULT_BACK_CAMERA, preview, imageAnalyzer ) } catch (exc: Exception) { Toast.makeText(this, "Gagal memunculkan kamera.", Toast.LENGTH_SHORT).show() } }, ContextCompat.getMainExecutor(this)) } } |
Pertama, kita inisialisasi dulu kelas ImageClassifierHelper dengan argument Context dan ClassifierListener. Untuk argument lain, kamu dapat mengubahnya atau membuat setting untuk pengaturan tersebut jika mau. Namun, pada latihan ini kita memanfaatkan default argument supaya tetap simpel.
Pada callback ClassifierListener, kita menampilkan Toast ketika terjadi error. Sedangkan apabila berhasil, kita menampilkan hasilnya dalam sebuah TextView. Tak lupa data yang ditampilkan diurutkan dulu dari skor (baca: keakuratan) tertinggi dan diubah dalam bentuk persentase.Â
Jangan lupa untuk menggunakan block runOnUiThread karena pada dasarnya kita tidak dapat meng-update UI dari background thread. Untuk itu, perlu diubah dulu menjadi UI thread dengan menggunakan block tersebut.
Kemudian ketika inisialisasi ImageAnalysis, kamu mengatur beberapa hal berikut.
- setTargetAspectRatio: Mengatur rasio aspek target gambar. Dalam hal ini, rasio aspek ditetapkan sebagai 4:3 supaya sesuai dengan model TFLite.
- setTargetRotation: Mengatur rotasi target gambar berdasarkan rotasi tampilan yang terkait dengan viewFinder. Ini memastikan bahwa gambar yang dianalisis sesuai dengan orientasi layar.
- setBackpressureStrategy: Mengatur strategi untuk mengatasi masalah penundaan dalam pemrosesan gambar. STRATEGY_KEEP_ONLY_LATEST memungkinkan analisis hanya menggunakan gambar terbaru jika gambar-gambar sebelumnya belum selesai diproses.
- setOutputImageFormat: Mengatur format gambar keluaran yang dihasilkan oleh ImageAnalysis menjadi RGBA 8888. Ini adalah format gambar yang mengandung komponen warna merah, hijau, biru, dan alfa dengan 8 bit per komponen.
- setAnalyzer: Di sini, kita mengatur analisis gambar dengan menjalankan sebuah executor tunggal yang akan menjalankan fungsi lambda yang akan menerima gambar sebagai input dan kemudian memanggil metode classify dari objek imageClassifierHelper untuk mengklasifikasikan gambar tersebut.
Setelah ImageAnalysis siap, sematkan objek tersebut pada argument keempat fungsi bindToLifecycle yang merupakan fitur untuk menambahkan use case tertentu pada CameraX, seperti analisis gambar di atas.
Oke, aplikasi untuk analisis sudah jadi. Mari, kita jalankan aplikasi pada perangkat dan lihat hasilnya.
Wih, mantap! Keren, bukan? Dengan kode yang tidak terlalu kompleks, kamu sudah dapat membuat aplikasi sendiri yang menerapkan machine learning untuk klasifikasi objek. Dapat dilihat bahwa data yang dihasilkan berjumlah tiga dan threshold di atas 10% sesuai dengan yang didefinisikan di konfigurasi.
Untuk melihat hasil jadi proyek, Anda dapat melihatnya pada tautan berikut.
Â
Apabila mengikuti tutorial ini dengan sungguh-sungguh, kamu menjadi memiliki kemampuan dasar untuk menerapkan TensorFlow Lite untuk semua jenis pemrosesan. Karena pada dasarnya semua jenis pemrosesan vision, memiliki dasar yang sama. Jadi, jika kamu ingin mengubahnya menjadi deteksi teks atau deteksi objek, tidak akan membutuhkan waktu yang lama.
Jika ingin belajar lebih dalam lagi terkait CameraX ataupun dasar pembuatan aplikasi lain, kamu juga dapat belajar di kelas Belajar Pengembangan Aplikasi Android Intermediate.Â
Harapannya, dengan memiliki dasar ini, kamu dapat membuat berbagai macam aplikasi sebagai solusi untuk permasalahan di sekitar kamu dengan memanfaatkan AI. Jika kamu memiliki ide aplikasi apa pun itu, silakan dituliskan di kolom komentar, ya! Semangat dan wujudkan aplikasi AI-mu!
